radboy 0.0.714__tar.gz → 0.0.715__tar.gz

{radboy-0.0.714 → radboy-0.0.715}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: radboy
-Version: 0.0.714
+Version: 0.0.715
 Summary: A Retail Calculator for Android/Linux
 Author: Carl Joseph Hirner III
 Author-email: Carl Hirner III <k.j.hirner.wisdom@gmail.com>

radboy-0.0.715/STDOUT.TXT

@@ -0,0 +1,10 @@
+#USER INPUT# -> :"t"
+#USER INPUT# -> :"fmlau"
+#USER INPUT# -> :"fcmd"
+#USER INPUT# -> :"volume"
+#USER INPUT# -> :"0"
+#USER INPUT# -> :"b"
+#USER INPUT# -> :"n"
+#USER INPUT# -> :"q"
+#USER INPUT# -> :"e"
+#USER INPUT# -> :"0.0.715"

{radboy-0.0.714 → radboy-0.0.715}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "radboy"
-version = "0.0.714"
+version = "0.0.715"
 authors = [
   { name="Carl Hirner III", email="k.j.hirner.wisdom@gmail.com" },
 ]

{radboy-0.0.714 → radboy-0.0.715}/radboy/TasksMode/Tasks.py

@@ -365,178 +365,181 @@ class Formulae:
     def __init__(self):
         pass
     def formulaeu(self):
-        while True:
-            try:
-                def timedecimal_to_ampm():
-                    dayHours=Prompt.__init2__(None,func=FormBuilderMkText,ptext="How many hours in a day?: ",helpText="how many hours make a day? default is 24 ",data="dec.dec")
-                    if dayHours is None:
-                        return
-                    elif dayHours in ['d',]:
-                        dayHours=Decimal('24')
-                    halfday=dayHours/2
+        with localcontext() as ctx:
+            ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+            while True:
+                try:
+                    def timedecimal_to_ampm():
+                        dayHours=Prompt.__init2__(None,func=FormBuilderMkText,ptext="How many hours in a day?: ",helpText="how many hours make a day? default is 24 ",data="dec.dec")
+                        if dayHours is None:
+                            return
+                        elif dayHours in ['d',]:
+                            dayHours=Decimal('24')
+                        halfday=dayHours/2
 
-                    result=None
-                    time_Dec=Prompt.__init2__(None,func=FormBuilderMkText,ptext="Time Decimal: ",helpText="time of day as a decimal to convert to 12H ",data="dec.dec")
-                    if time_Dec is None:
-                        return
-                    elif time_Dec in ['d',]:
-                        time_Dec=0.0
-                    ampm='am'
-                    if time_Dec >= 0 and time_Dec <= dayHours:
-                        if time_Dec <= halfday:
-                            hours=int(time_Dec)
-                        else:
-                            hours=int(time_Dec-halfday)
-                            ampm='pm'
-                        minutes=time_Dec-int(time_Dec)
-                        
-                        try:
-                            minutes=int(minutes*60)
-                        except Exception as e:
-                            print(e)
-                            minutes=0
-                        result=f"{hours}[12H]/{int(time_Dec)}[24]:{minutes} {ampm}"
-                        
+                        result=None
+                        time_Dec=Prompt.__init2__(None,func=FormBuilderMkText,ptext="Time Decimal: ",helpText="time of day as a decimal to convert to 12H ",data="dec.dec")
+                        if time_Dec is None:
+                            return
+                        elif time_Dec in ['d',]:
+                            time_Dec=0.0
+                        ampm='am'
+                        if time_Dec >= 0 and time_Dec <= dayHours:
+                            if time_Dec <= halfday:
+                                hours=int(time_Dec)
+                            else:
+                                hours=int(time_Dec-halfday)
+                                ampm='pm'
+                            minutes=time_Dec-int(time_Dec)
+                            
+                            try:
+                                minutes=int(minutes*60)
+                            except Exception as e:
+                                print(e)
+                                minutes=0
+                            result=f"{hours}[12H]/{int(time_Dec)}[24]:{minutes} {ampm}"
+                            
+                            return result
                         return result
-                    return result
 
-                def invert_value():
-                    result=None
-                    value=Prompt.__init2__(None,func=FormBuilderMkText,ptext="Value to Invert: ",helpText="make user provided value, or formula negative (value*-1='-value')",data="dec.dec")
-                    if value is None:
-                        return
-                    elif value in ['d',]:
-                        value=0
-                    result=value*-1
-                    return result
+                    def invert_value():
+                        result=None
+                        value=Prompt.__init2__(None,func=FormBuilderMkText,ptext="Value to Invert: ",helpText="make user provided value, or formula negative (value*-1='-value')",data="dec.dec")
+                        if value is None:
+                            return
+                        elif value in ['d',]:
+                            value=0
+                        result=value*-1
+                        return result
 
-                def tax_rate_decimal():
-                    result=None
-                    tax_percent=Prompt.__init2__(None,func=FormBuilderMkText,ptext="Tax Rate Percent: ",helpText="percent to convert to decimal (Percent/100=Rate)",data="dec.dec")
-                    if tax_percent is None:
-                        return
-                    elif tax_percent in ['d',]:
-                        tax_percent=default_taxrate/100
-                    result=tax_percent/100
-                    return result
+                    def tax_rate_decimal():
+                        result=None
+                        tax_percent=Prompt.__init2__(None,func=FormBuilderMkText,ptext="Tax Rate Percent: ",helpText="percent to convert to decimal (Percent/100=Rate)",data="dec.dec")
+                        if tax_percent is None:
+                            return
+                        elif tax_percent in ['d',]:
+                            tax_percent=default_taxrate/100
+                        result=tax_percent/100
+                        return result
 
-                
+                    
 
-                self.options={
-                    f'{uuid1()}':{
-                        'cmds':['invert','-value','iv-val'],
-                        'desc':f'{Fore.light_yellow}value{Fore.medium_violet_red} is multiplied by -1 to make inverse{Style.reset}',
-                        'exec':invert_value
-                    },
-                    f'{uuid1()}':{
-                        'cmds':['time dec to clock','t2c','time to clock'],
-                        'desc':f'{Fore.light_yellow}value{Fore.medium_violet_red} convert decimal time to clock time{Style.reset}',
-                        'exec':timedecimal_to_ampm
-                    },
-                    f'{uuid1()}':{
-                        'cmds':['percent to decimal','p2d','prcnt2decimal','prcnt 2 dec'],
-                        'desc':f'{Fore.light_yellow}decimal (0.02) {Fore.medium_violet_red} from percent (2%->2){Style.reset}',
-                        'exec':tax_rate_decimal
-                    },
-                    f'{uuid1()}':{
-                        'cmds':['basic counter','bcounter','countto','count to'],
-                        'desc':f'{Fore.light_yellow}decimal (0.02) {Fore.medium_violet_red} from percent (2%->2){Style.reset}',
-                        'exec':OAR.CountTo
-                    },
-                }
-                
-                for i in preloader:
-                    self.options[i]=preloader[i]
-                defaults_msg=f'''
-                '''
-                '''must be last for user to always see'''
-                self.options[f'{uuid1()}']={
-                        'cmds':['fcmd','findcmd','find cmd'],
-                        'desc':f'Find {Fore.light_yellow}cmd{Fore.medium_violet_red} and excute for return{Style.reset}',
-                        'exec':self.findAndUse2
+                    self.options={
+                        f'{uuid1()}':{
+                            'cmds':['invert','-value','iv-val'],
+                            'desc':f'{Fore.light_yellow}value{Fore.medium_violet_red} is multiplied by -1 to make inverse{Style.reset}',
+                            'exec':invert_value
+                        },
+                        f'{uuid1()}':{
+                            'cmds':['time dec to clock','t2c','time to clock'],
+                            'desc':f'{Fore.light_yellow}value{Fore.medium_violet_red} convert decimal time to clock time{Style.reset}',
+                            'exec':timedecimal_to_ampm
+                        },
+                        f'{uuid1()}':{
+                            'cmds':['percent to decimal','p2d','prcnt2decimal','prcnt 2 dec'],
+                            'desc':f'{Fore.light_yellow}decimal (0.02) {Fore.medium_violet_red} from percent (2%->2){Style.reset}',
+                            'exec':tax_rate_decimal
+                        },
+                        f'{uuid1()}':{
+                            'cmds':['basic counter','bcounter','countto','count to'],
+                            'desc':f'{Fore.light_yellow}decimal (0.02) {Fore.medium_violet_red} from percent (2%->2){Style.reset}',
+                            'exec':OAR.CountTo
+                        },
                     }
-                for num,i in enumerate(self.options):
-                    if str(num) not in self.options[i]['cmds']:
-                        self.options[i]['cmds'].append(str(num))
-                options=copy(self.options)
+                    
+                    for i in preloader:
+                        self.options[i]=preloader[i]
+                    defaults_msg=f'''
+                    '''
+                    '''must be last for user to always see'''
+                    self.options[f'{uuid1()}']={
+                            'cmds':['fcmd','findcmd','find cmd'],
+                            'desc':f'Find {Fore.light_yellow}cmd{Fore.medium_violet_red} and excute for return{Style.reset}',
+                            'exec':self.findAndUse2
+                        }
+                    for num,i in enumerate(self.options):
+                        if str(num) not in self.options[i]['cmds']:
+                            self.options[i]['cmds'].append(str(num))
+                    options=copy(self.options)
 
-                while True:                
-                    helpText=[]
-                    for i in options:
-                        msg=f"{Fore.light_green}{options[i]['cmds']}{Fore.light_red} -> {options[i]['desc']}{Style.reset}"
-                        helpText.append(msg)
-                    helpText='\n'.join(helpText)
-                    print(helpText)
-                    print(defaults_msg)
-                    cmd=Prompt.__init2__(None,func=FormBuilderMkText,ptext="Quick Formulas|Do What?:",helpText=helpText,data="string")
-                    if cmd is None:
-                        return None
-                    result=None
-                    for i in options:
-                        els=[ii.lower() for ii in options[i]['cmds']]
-                        if cmd.lower() in els:
-                            result=options[i]['exec']()
-                            break
-                    print(f"{result}")
-                    returnResult=Prompt.__init2__(None,func=FormBuilderMkText,ptext="[Formula] Return Result?[y/n]",helpText=f"result to return is '{result}'",data="boolean")
-                    if returnResult in [True,]:
-                        if result is None:
+                    while True:                
+                        helpText=[]
+                        zt=len(options)
+                        for num,i in enumerate(options):
+                            msg=f"{Fore.light_green}{options[i]['cmds']}{Fore.light_red} -> {options[i]['desc']}{Style.reset}"
+                            helpText.append(std_colorize(msg,num,zt))
+                        helpText='\n'.join(helpText)
+                        print(helpText)
+                        print(defaults_msg)
+                        cmd=Prompt.__init2__(None,func=FormBuilderMkText,ptext="Quick Formulas|Do What?:",helpText=helpText,data="string")
+                        if cmd is None:
                             return None
-                        else:
-                            returnTypes=["float","Decimal","string","string"]
-                            returnActor=[lambda x:round(float(x),4),lambda x:Decimal(x).quantize(Decimal("0.0000")),lambda x: f"{x:.4f}",lambda x:str(x)]
-                            ct=len(returnTypes)
-                            returnType=None
-                            htext=[]
-                            strOnly=False
-                            for num,i in enumerate(returnTypes):
-                                try:
-                                    htext.append(std_colorize(f"{i} - {returnActor[num](result)} ",num,ct))
-                                except Exception as e:
-                                    strOnly=True
-                                    print(e)
-                            htext='\n'.join(htext)
-                            while returnType not in range(0,ct+1):
-                                print(htext)
-                                returnType=Prompt.__init2__(self,func=FormBuilderMkText,ptext="Return the value as?",helpText=f"{htext}\nwhich index?",data="integer")
-                                if returnType is None:
-                                    return None
-                                elif returnType in ['d',]:
-                                    if not strOnly:   
-                                        returnType=1
-                                    else:
-                                        returnType=-1
-                                        break
-                                        #return str(result)
-                            try:
-                                if returnTypes[returnType] == 'float':
-                                    try:
-                                        return returnActor[returnType](result)
-                                    except Exception as e:
-                                        print(e)
-                                        continue
-                                elif returnTypes[returnType] == 'Decimal':
-                                    try:
-                                        return returnActor[returnType](result)
-                                    except Exception as e:
-                                        print(e)
-                                        continue
-                                elif returnTypes[returnType] == 'string':
+                        result=None
+                        for i in options:
+                            els=[ii.lower() for ii in options[i]['cmds']]
+                            if cmd.lower() in els:
+                                result=options[i]['exec']()
+                                break
+                        print(f"{result}")
+                        returnResult=Prompt.__init2__(None,func=FormBuilderMkText,ptext="[Formula] Return Result?[y/n]",helpText=f"result to return is '{result}'",data="boolean")
+                        if returnResult in [True,]:
+                            if result is None:
+                                return None
+                            else:
+                                returnTypes=["float","Decimal","string","string"]
+                                returnActor=[lambda x:round(float(x),4),lambda x:Decimal(x),lambda x: f"{x:.4f}",lambda x:str(x)]
+                                ct=len(returnTypes)
+                                returnType=None
+                                htext=[]
+                                strOnly=False
+                                for num,i in enumerate(returnTypes):
                                     try:
-                                        return returnActor[returnType](result)
+                                        htext.append(std_colorize(f"{i} - {returnActor[num](result)} ",num,ct))
                                     except Exception as e:
+                                        strOnly=True
                                         print(e)
-                                        continue
-                                else:
+                                htext='\n'.join(htext)
+                                while returnType not in range(0,ct+1):
+                                    print(htext)
+                                    returnType=Prompt.__init2__(self,func=FormBuilderMkText,ptext="Return the value as?",helpText=f"{htext}\nwhich index?",data="integer")
+                                    if returnType is None:
+                                        return None
+                                    elif returnType in ['d',]:
+                                        if not strOnly:   
+                                            returnType=1
+                                        else:
+                                            returnType=-1
+                                            break
+                                            #return str(result)
+                                try:
+                                    if returnTypes[returnType] == 'float':
+                                        try:
+                                            return returnActor[returnType](result)
+                                        except Exception as e:
+                                            print(e)
+                                            continue
+                                    elif returnTypes[returnType] == 'Decimal':
+                                        try:
+                                            return returnActor[returnType](result)
+                                        except Exception as e:
+                                            print(e)
+                                            continue
+                                    elif returnTypes[returnType] == 'string':
+                                        try:
+                                            return returnActor[returnType](result)
+                                        except Exception as e:
+                                            print(e)
+                                            continue
+                                    else:
+                                        return result
+                                except Exception as e:
+                                    print(e)
+                                    print("returning as a string")
                                     return result
-                            except Exception as e:
-                                print(e)
-                                print("returning as a string")
-                                return result
-                        return result                
-            except Exception as e:
-                print(e,str(e),repr(e))
-                return None
+                            return result                
+                except Exception as e:
+                    print(e,str(e),repr(e))
+                    return None
             
 
     def pricing(self):

radboy-0.0.715/radboy/__init__.py

@@ -0,0 +1 @@
+VERSION='0.0.715'

radboy-0.0.715/radboy/preloader/preloader.py

@@ -0,0 +1,196 @@
+from . import *
+
+
+preloader={
+	f'{uuid1()}':{
+						'cmds':['volume',],
+						'desc':f'find the volume of height*width*length without dimensions',
+						'exec':volume
+					},
+	f'{uuid1()}':{
+						'cmds':['volume pint',],
+						'desc':f'find the volume of height*width*length using pint to normalize the values',
+						'exec':volume_pint
+					},
+	f'{uuid1()}':{
+						'cmds':['self-inductance pint',],
+						'desc':f'find self-inductance using pint to normalize the values for self-inductance=relative_permeability*(((turns**2)*area)/length)*1.26e-6',
+						'exec':inductance_pint
+					},
+	f'{uuid1()}':{
+						'cmds':['required resonant LC inductance',],
+						'desc':f'find the resonant inductance for LC using L = 1 / (4π²f²C)',
+						'exec':resonant_inductance
+					},
+	f'{uuid1()}':{
+						'cmds':['air coil',],
+						'desc':f''' 
+The formula for inductance - using toilet rolls, PVC pipe etc. can be well approximated by:
+
+                (0.394) * (r**2) * (N**2)
+Inductance L = _________________________
+              	( 9 * r ) + ( 10 * Len)
+Here:
+	N = Number of Turns 
+	r = radius of the coil i.e. form diameter (in cm.) divided by 2
+	Len = length of the coil - again in cm.
+	L = inductance in uH.
+	* = multiply by
+	math.pi**2==0.394
+						''',
+						'exec':air_coil
+					},
+					f'{uuid1()}':{
+						'cmds':['circumference of a circle using diameter',],
+						'desc':f'C=2πr',
+						'exec':circumference_diameter
+					},
+					f'{uuid1()}':{
+						'cmds':['circumference of a circle using radius',],
+						'desc':f'C=2πr',
+						'exec':circumference_radius
+					},
+					f'{uuid1()}':{
+						'cmds':['area of a circle using diameter',],
+						'desc':f'A = πr²',
+						'exec':area_of_circle_diameter
+					},
+					f'{uuid1()}':{
+						'cmds':['area of a circle using radius',],
+						'desc':f'A = πr²',
+						'exec':area_of_circle_radius
+					},
+					f'{uuid1()}':{
+						'cmds':['get capacitance for desired frequency with specific inductance',],
+						'desc':f'C = 1 / (4π²f²L)²',
+						'exec':air_coil_cap,
+					},
+					f'{uuid1()}':{
+						'cmds':['get resonant frequency for lc circuit',],
+						'desc':f'f = 1 / (2π√(LC))',
+						'exec':lc_frequency,
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['triangle','trngl'],endCmd=['area','a'])],
+						'desc':f'A=BH/2 = area of a triangle',
+						'exec':area_triangle,
+					},
+					f'{uuid1()}':{
+						'cmds':['taxable kombucha',],
+						'desc':f'is kombucha taxable?[taxable=True,non-taxable=False]',
+						'exec':lambda: Taxable.kombucha(None),
+					},
+					f'{uuid1()}':{
+						'cmds':['taxable item',],
+						'desc':f'is item taxable?[taxable=True,non-taxable=False]',
+						'exec':lambda: Taxable.general_taxable(None),
+					},
+					f'{uuid1()}':{
+						'cmds':['price * rate = tax',],
+						'desc':f'multiply a price times its tax rate ; {Fore.orange_red_1}Add this value to the price for the {Fore.light_steel_blue}Total{Style.reset}',
+						'exec':lambda: price_by_tax(total=False),
+					},
+					f'{uuid1()}':{
+						'cmds':['( price + crv ) * rate = tax',],
+						'desc':f'multiply a (price+crv) times its tax rate ; {Fore.orange_red_1}Add this value to the price for the {Fore.light_steel_blue}Total{Style.reset}',
+						'exec':lambda: price_plus_crv_by_tax(total=False),
+					},
+					f'{uuid1()}':{
+						'cmds':['(price * rate) + price = total',],
+						'desc':f'multiply a price times its tax rate + price return the total',
+						'exec':lambda: price_by_tax(total=True),
+					},
+					f'{uuid1()}':{
+						'cmds':['( price + crv ) + (( price + crv ) * rate) = total',],
+						'desc':f'multiply a (price+crv) times its tax rate plus (price+crv) and return the total',
+						'exec':lambda: price_plus_crv_by_tax(total=True),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['cylinder','clndr'],endCmd=['vol rad','volume radius'])],
+						'desc':f'obtain the volume of a cylinder using radius',
+						'exec':lambda: volumeCylinderRadius(),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['cylinder','clndr'],endCmd=['vol diam','volume diameter'])],
+						'desc':f'obtain the volume of a cylinder using diameter',
+						'exec':lambda: volumeCylinderDiameter(),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['cone',],endCmd=['vol rad','volume radius'])],
+						'desc':f'obtain the volume of a cone using radius, a cone is 1/3 of a cylinder at the same height and radius',
+						'exec':lambda: volumeConeRadius(),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['cone',],endCmd=['vol diam','volume diameter'])],
+						'desc':f'obtain the volume of a cone using diameter, a code is 1/3 of a cylinder at the same height and diameter',
+						'exec':lambda: volumeConeDiameter(),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['hemisphr','hemisphere'],endCmd=['vol rad','volume radius'])],
+						'desc':f'obtain the volume of a hemisphere using radius',
+						'exec':lambda: volumeHemisphereRadius(),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['hemisphr','hemisphere'],endCmd=['vol diam','volume diameter'])],
+						'desc':f'obtain the volume of a hemisphere using diameter',
+						'exec':lambda: volumeHemisphereDiameter(),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['circle',],endCmd=['area radius','area rad'])],
+						'desc':f'obtain the area of a circle using radius',
+						'exec':lambda: areaCircleRadius(),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['circle',],endCmd=['area diameter','area diam'])],
+						'desc':f'obtain the area of a circle using diameter',
+						'exec':lambda: areaCircleDiameter(),
+					},
+					f'{uuid1()}':{
+						'cmds':['herons formula','hrns fmla'],
+						'desc':f'''
+Heron's formula calculates the area of any 
+triangle given only the lengths of its 
+three sides (a, b, and c). The formula is: 
+Area = √(s(s-a)(s-b)(s-c)). To use it, first
+ calculate the semi-perimeter, s = (a + b 
+ + c) / 2, and then substitute this value 
+ and the side lengths into the formula to 
+ find the area. 
+						''',
+						'exec':lambda: heronsFormula(),
+					},
+					f'{uuid1()}':{
+						'cmds':['tax add',],
+						'desc':'''AddNewTaxRate() -> None
+
+add a new taxrate to db.''',
+						'exec':lambda: AddNewTaxRate(),
+					},
+					f'{uuid1()}':{
+						'cmds':['tax get',],
+						'desc':	'''GetTaxRate() -> TaxRate:Decimal
+
+search for and return a Decimal/decc
+taxrate for use by prompt.
+''',
+						'exec':lambda: GetTaxRate(),
+					},
+					f'{uuid1()}':{
+						'cmds':['tax delete',],
+						'desc':'''DeleteTaxRate() -> None
+
+search for and delete selected
+taxrate.
+''',
+						'exec':lambda: DeleteTaxRate(),
+					},
+					f'{uuid1()}':{
+						'cmds':['tax edit',],
+						'desc':'''EditTaxRate() -> None
+
+search for and edit selected
+taxrate.
+''',
+						'exec':lambda: EditTaxRate(),
+					},
+}