Example #1
0
 def rest(self,
          method,
          uri,
          data=None,
          status_codes=None,
          parse=True,
          **kwargs):
     """ Rest helpers
 """
     r = self.pool.request_encode_body(method,
                                       uri,
                                       fields=data,
                                       encode_multipart=False)
     if not r.status in (status_codes if status_codes else (200, 201)):
         print cl('\n---------\nURI / REQUEST TYPE : %s %s' % (uri, method),
                  'red')
         print cl(data, 'red')
         print r.headers
         raise Exception, "Invalid status code: %s" % r.status
     if not parse:
         " return raw urllib3 response"
         return r
     if not self.debug_loads:
         " return parsed edn"
         return loads(r.data)
     "time edn parse time and return parsed edn"
     return self.debug(loads,
                       args=(r_data, ),
                       kwargs={},
                       fmt='<<< parsed edn datastruct in {ms}ms',
                       color='green')
Example #2
0
def clear():
    clear = input(cl('clear text files (yes or no): ', 'white'))
    if clear == 'yes':
        pick = input(cl('valid, notvalid, or both: ', 'white'))
        if pick == 'valid':
            file = open("YESvalid.txt", "w+")
            file.write("")
            file.close()
        elif pick == 'notvalid':
            file = open("NOTvalid.txt", "w+")
            file.write("")
            file.close()
        elif pick == 'both':
            file = open("YESvalid.txt", "w+")
            file.write("")
            file.close()
            file = open("NOTvalid.txt", "w+")
            file.write("")
            file.close()
        else:
            print('\033[H\033[J')
            print(cl('invalid choice', 'red'))
            t.sleep(3)
            os.system('python3 main.py')
    elif clear == 'no':
        print('files wont be cleared\n')
    else:
        print('\033[H\033[J')
        print(cl('invalid choice', 'red'))
        t.sleep(3)
        print('\033[H\033[J')
        os.system('python3 main.py')
Example #3
0
  def datoms(self, index='aevt', e='', a='', v='', 
                   limit=0, offset=0, chunk=100, 
                   start='', end='', since='', as_of='', history='', **kwargs):
    """ Returns a lazy generator that will only fetch groups of datoms
        at the chunk size specified.

    http://docs.datomic.com/clojure/index.html#datomic.api/datoms
    """
    assert index in ['aevt','eavt','avet','vaet'], "non-existant index"
    data = {'index':   index, 
            'a':       ':{0}'.format(a) if a else '',
            'v':       dump_edn_val(v) if v else '',
            'e':       int(e) if e else '', 
            'offset':  offset or 0,
            'start':   start,
            'end':     end,
            'limit':   limit,
            'history': 'true' if history else '',
            'as-of':   int(as_of) if as_of else '',
            'since':   int(since) if since else '',
            }
    data['limit'] = offset + chunk
    rs = True
    while rs and (data['offset'] < (limit or 1000000000)):
      ta = datetime.datetime.now()
      rs = self.rest('GET', self.uri_db + '-/datoms', data=data, parse=True)
      if not len(rs):
        rs = False
      tb = datetime.datetime.now() - ta
      print cl('<<< fetched %i datoms at offset %i in %sms' % (
        len(rs), data['offset'], tb.microseconds/1000.0), 'cyan')
      for r in rs: yield r
      data['offset'] += chunk
Example #4
0
def look_up(word):
    url = 'http://dict.youdao.com/search?q='
    r = requests.get(url + word)
    content = r.text

    try:
        ps = re.findall(re.compile('"phonetic">(.*?)</span>'), content)
        pattern = re.compile('"trans-container">(.*?)</div>', re.S)
        tmp = re.findall(pattern, content)
        mean = re.findall(re.compile('<li>(.*?)</li>'), tmp[0])
    except:
        print('Can\'t find it')
        return

    if len(ps) is 2:
            print(cl(u'英{0} 美{1}'.format(ps[0], ps[1]), 'cyan'))
    else:
        try:
            print(cl(ps[0], 'cyan'))
        except:
            pass
    for line in mean:
        words = line.split('.', 1)
        if len(words) is 2:
            words[0] += '.'
            print(u'{0}{1}'.format(cl(words[0], 'green'), cl(words[1], 'blue')))
            # word
        else:
            print(u'{0}'.format(cl(words[0], 'blue')))
Example #5
0
 def e(self, eid):
   """Get an Entity
   """
   ta = datetime.datetime.now()
   rs = self.rest('GET', self.uri_db + '-/entity', data={'e':int(eid)}, parse=True)
   tb =  datetime.datetime.now() - ta
   print cl('<<< fetched entity %s in %sms' % (eid, tb.microseconds/1000.0), 'cyan')
   return rs
Example #6
0
def main():
    
    print(cl("~~~~~~~~~~~~~~~Word of the Day~~~~~~~~~~~~~~~~", "grey"))
    wordADay()
    print(cl("~~~~~~~~~~~~~~~Quote for the Day~~~~~~~~~~~~~~", "grey"))
    quoteADay()
    print(cl("~~~~~~~~~~~~~German Word of the Day~~~~~~~~~~~~~", "grey"))
    deustchesWort()
Example #7
0
def modela_kvalitate(y_test, resultats):
    # Kvalitate virs 0.6 ir OK
    print(
        cl('Explained Variance Score (dispersija): {}'.format(
            evs(y_test, resultats)),
           attrs=['bold']))
    print(
        cl('R-Squared (kvadratiska novirze): {}'.format(r2(y_test, resultats)),
           attrs=['bold']))
Example #8
0
def info(datne):
    print(cl("\n\nInformācija par datni " + datne, 'green', attrs = ['reverse']))
    # # importējam datus
    # # df is saīsinajums no Data Frame, 
    # # Pandas bibliotēkas pamata datu struktūras
    df = pd.read_csv(datne)
    # # apskatīt pirmās 5 datu rindiņas
    print(cl("\nPirmās 5 rindiņas", attrs = ['bold']))
    print(df.head(5))
Example #9
0
 def retract(self, e, a, v):
   """ redact the value of an attribute
   """
   ta = datetime.datetime.now()
   ret = u"[:db/retract %i :%s %s]" % (e, a, dump_edn_val(v))
   rs = self.tx(ret)
   tb = datetime.datetime.now() - ta
   print cl('<<< retracted %s,%s,%s in %sms' % (e,a,v, tb.microseconds/1000.0), 'cyan')
   return rs
Example #10
0
def targets(name=None):
    return cl('''
    TARGETS:''', 'red') + cl(
        ''' (-trgt)
        
        [ zervit = Zervit 0.4 for Windows ]
        [ cuppa  = CUPPA CMS vb.0..1 for FreeBSD ]
        [ wbm128 = Webmin 1.28 for Fedora Core 4 ]
        [ iweb   = Ashley Brown iWeb Server for Windows ]
    ''', 'white')
Example #11
0
 def retract(self, e, a, v):
     """ redact the value of an attribute
 """
     ta = datetime.datetime.now()
     ret = u"[:db/retract %i :%s %s]" % (e, a, dump_edn_val(v))
     rs = self.tx(ret)
     tb = datetime.datetime.now() - ta
     print cl(
         '<<< retracted %s,%s,%s in %sms' %
         (e, a, v, tb.microseconds / 1000.0), 'cyan')
     return rs
Example #12
0
def fibNum(n):
    goldenRatio = 1.61803
    #https://en.wikipedia.org/wiki/Fibonacci_number
    #Used the formula concerning golden ratio to create a 
    #comprehension list to hold the Fibonacci sequence and see if 
    #n is part of that sequence
    seq = [round(((goldenRatio ** i) - (1-goldenRatio)**i)/math.sqrt(5)) for i in range(1001)]
    if int(n) in seq:
        print(cl("The number you gave is a part of the Fibonacci sequence!", "blue"))
    else:
        print(cl("Sorry! That number is not a part of the Fibonacci sequence!", "red"))
    del seq
Example #13
0
 def e(self, eid):
     """Get an Entity
 """
     ta = datetime.datetime.now()
     rs = self.rest('GET',
                    self.uri_db + '-/entity',
                    data={'e': int(eid)},
                    parse=True)
     tb = datetime.datetime.now() - ta
     print cl(
         '<<< fetched entity %s in %sms' % (eid, tb.microseconds / 1000.0),
         'cyan')
     return rs
Example #14
0
 def debug(self, defn, args, kwargs, fmt=None, color='green'):
     """ debug timing, colored terminal output
 """
     ta = datetime.datetime.now()
     rs = defn(*args, **kwargs)
     tb = datetime.datetime.now() - ta
     fmt = fmt or "processed {defn} in {ms}ms"
     logmsg = fmt.format(ms=tb.microseconds / 1000.0, defn=defn)
     "terminal output"
     print cl(logmsg, color)
     "logging output"
     logging.debug(logmsg)
     return rs
Example #15
0
 def debug(self, defn, args, kwargs, fmt=None, color='green'):
   """ debug timing, colored terminal output
   """
   ta = datetime.datetime.now()
   rs = defn(*args, **kwargs)  
   tb = datetime.datetime.now() - ta
   fmt = fmt or "processed {defn} in {ms}ms"
   logmsg = fmt.format(ms=tb.microseconds/1000.0, defn=defn)
   "terminal output"
   print cl(logmsg, color)
   "logging output"
   logging.debug(logmsg)
   return rs
Example #16
0
    def datoms(self,
               index='aevt',
               e='',
               a='',
               v='',
               limit=0,
               offset=0,
               chunk=100,
               start='',
               end='',
               since='',
               as_of='',
               history='',
               **kwargs):
        """ Returns a lazy generator that will only fetch groups of datoms
        at the chunk size specified.

    http://docs.datomic.com/clojure/index.html#datomic.api/datoms
    """
        assert index in ['aevt', 'eavt', 'avet', 'vaet'], "non-existant index"
        data = {
            'index': index,
            'a': ':{0}'.format(a) if a else '',
            'v': dump_edn_val(v) if v else '',
            'e': int(e) if e else '',
            'offset': offset or 0,
            'start': start,
            'end': end,
            'limit': limit,
            'history': 'true' if history else '',
            'as-of': int(as_of) if as_of else '',
            'since': int(since) if since else '',
        }
        data['limit'] = offset + chunk
        rs = True
        while rs and (data['offset'] < (limit or 1000000000)):
            ta = datetime.datetime.now()
            rs = self.rest('GET',
                           self.uri_db + '-/datoms',
                           data=data,
                           parse=True)
            if not len(rs):
                rs = False
            tb = datetime.datetime.now() - ta
            print cl(
                '<<< fetched %i datoms at offset %i in %sms' %
                (len(rs), data['offset'], tb.microseconds / 1000.0), 'cyan')
            for r in rs:
                yield r
            data['offset'] += chunk
    def printBoard(self, s, b, score, x, y, count, bx, by, life, level):
        print("Your Score is ", score)
        print("No of lives left ", life)
        print("You are on level ", level)
        print("Press q to quit")
        for i in range(42):
            for j in range(68):
                if s[i][j] == 2:
                    print(cl("^", "yellow"), end="")
                elif b[i][j] == 2:
                    print(cl("E", "red"), end="")
                elif b[i][j] == 1:
                    print(cl("B", "white"), end="")
                elif s[i][j] == 0 and b[i][j] == 0:
                    print(" ", end="")
                elif s[i][j] == 1 and b[i][j] == 0:
                    print(cl("#", "cyan"), end="")

                elif s[i][j] == 3 and b[i][j] == 0:
                    if j == by:
                        print(cl("[", "yellow"), end="")
                    elif j == by + 1 or j == by + 2:
                        print(cl(count, "yellow"), end="")
                    elif j == by + 3:
                        print(cl("]", "yellow"), end="")

                elif s[i][j] == 4 and b[i][j] == 0:
                    print(cl("/", "green"), end="")

            print(" ")
Example #18
0
 def rest(self, method, uri, data=None, status_codes=None, parse=True, **kwargs):
   """ Rest helpers
   """
   r = self.pool.request_encode_body(method, uri, fields=data, encode_multipart=False)
   if not r.status in (status_codes if status_codes else (200,201)):
     print cl('\n---------\nURI / REQUEST TYPE : %s %s' % (uri, method), 'red')
     print cl(data, 'red')
     print r.headers
     raise Exception, "Invalid status code: %s" % r.status
   if not parse: 
     " return raw urllib3 response"
     return r
   if not self.debug_loads:
     " return parsed edn"
     return loads(r.data)
   "time edn parse time and return parsed edn"
   return self.debug(loads, args=(r_data, ), kwargs={},
         fmt='<<< parsed edn datastruct in {ms}ms', color='green')
def ievade():
    turpinam = True
    modelis = ieladet_modeli("ss-modelis.pickle")
    print(
        cl("Auto cenu prognoze. Ievadiet pieprasītos datus, lai saņemtu prognozi.",
           "green",
           attrs=["reverse"]))
    while turpinam:
        gads = int(input("Auto izlaišanas gads vai 0, lai izietu: "))
        if gads == 0:
            turpinam = False
            continue
        tilpums = float(input("Dzinēja tilpums: "))
        nobraukums = float(input("Nobraukums, tūkstošos km.: "))
        dati = [[gads, tilpums, nobraukums]]
        prognoze = prognozejam_rezultatu(modelis, dati)
        print("Prognozētā cena:",
              cl(round(prognoze[0]), "green", attrs=["bold"]))
        print()
Example #20
0
def quoteADay():
    
    goodReads = "https://www.goodreads.com/quotes"
    goodClient = req(goodReads)
    site_parse_quote = soup(goodClient.read(), "lxml")
    goodClient.close()
    
    #Pull from the left container 
    quotesOnly = site_parse_quote.find("div", {"class": "leftContainer"})
    #Randomly choose a quote from the front page
    ranQuote = quotesOnly.find("div", {"class": "quotes"}).findAll("div", {"class": "quote"})[rn.randrange(30)]
    #Pull info from ranQuote
    sourceQuote = ranQuote.find("span").text.strip()
    quote = ranQuote.find("div", {"class": "quoteText"}).text.strip().split('\n')[0]
    #Give a little background info about the author of the quote
    authorInfo = wiki.summary(sourceQuote, sentences=1)
    
    print(cl(quote, "green"))
    print(cl('~'+'\033[1m'+sourceQuote+'~', "magenta"))
    print(cl(authorInfo, "magenta"))
Example #21
0
def banner(name=None):
    return '''
   ---------------------------------------------------------------
''' + cl(
        '''  ██╗     ███████╗██╗████████╗███████╗██████╗  ██████╗     ██████╗
  ██║     ██╔════╝██║╚══██╔══╝██╔════╝██╔══██╗ ╚════██╗   ██╔═████╗
  ██║     █████╗  ██║   ██║   █████╗  ██████╔╝  █████╔╝   ██║██╔██║
  ██║     ██╔══╝  ██║   ██║   ██╔══╝  ██╔══██╗ ██╔═══╝    ████╔╝██║
  ███████╗██║     ██║   ██║   ███████╗██║  ██║ ███████╗██╗╚██████╔╝
  ╚══════╝╚═╝     ╚═╝   ╚═╝   ╚══════╝╚═╝  ╚═╝ ╚══════╝╚═╝ ╚═════╝
''', 'red'
    ) + '''   ------------------------------------------------ By 3mrgnc3 ---
def taskSix():
    """
    Write a program with a variable 'age' assigned to an integer 
    that prints different strings depending on what integer 'age' is
    """

    quote_one = """The timeless in you is aware of life's timelessness.
    And knows that yesterday is but today's memory and tomorrow is today's dream.
    ~ Khalil Gibran"""
    quote_two = "What happens when people open their hearts? They get better. ~ Haruki Murakami"
    quote_three = "You only live once, but if you do it right, once is enough. ~ Mae West"
    quote_four = """I've learned that people will forget what you said, 
    people will forget what you did, but people will never forget 
    how you made them feel.
    ~ Maya Angelou"""
    quote_five = """Non est ad astra mollis e terris via.
    (There is no easy way from the earth to the stars)
    ~ Seneca"""

    age = input("How old are you? ")

    if int(age) <= 10:
        print(cl("Life has yet begun for you!", "cyan"))
    elif int(age) > 10 and int(age) <= 20:
        print(cl(quote_one + "\n", "magenta"))
    elif int(age) > 20 and int(age) <= 40:
        print(cl(quote_two + "\n", "blue"))
    elif int(age) > 40 and int(age) <= 60:
        print(cl(quote_three + "\n", "green"))
    elif int(age) > 60 and int(age) <= 80:
        print(cl(quote_four + "\n", "magenta"))
    elif int(age) > 80:
        print(cl(quote_five + "\n", "cyan"))
def taskOne():
    #Print three different strings
    #I added a bit more to this task by pulling three different
    #quotes from GoodReads
    goodReads = "https://www.goodreads.com/quotes"
    goodClient = req(goodReads)
    quote_parse = soup(goodClient.read(), "lxml")
    goodClient.close()

    #Hold quotes into list from main page
    hold = quote_parse.find_all("div", {"class": "quoteText"})

    #String one prints a random quote with its author
    strOneRn = rn.randrange(30)
    strOneQte = hold[strOneRn].text.strip().split("\n")[0]
    strOneAthr = hold[strOneRn].text.strip().split("\n")[3].strip()
    string_one = strOneQte + " ~ " + strOneAthr.strip()

    #String two prints a random quote with its author
    strTwoRn = rn.randrange(30)
    strTwoRan = rn.randint(0, 30) if strTwoRn == strOneRn else strTwoRn
    strTwoQte = hold[strTwoRan].text.strip().split("\n")[0]
    strTwoAthr = hold[strTwoRan].text.strip().split("\n")[3].strip()
    string_two = strTwoQte + " ~ " + strTwoAthr.strip()

    #String three prints a random quote with its author
    strThreeRn = rn.randrange(30)
    strThreeRan = rn.randint(
        0, 30) if strThreeRn == (strTwoRn or strOneRn) else strThreeRn
    strThreeQte = hold[strThreeRan].text.strip().split("\n")[0]
    strThreeAthr = hold[strThreeRan].text.strip().split("\n")[3].strip()
    string_three = strThreeQte + " ~ " + strThreeAthr.strip()

    print("This task prints out three strings, or rather three quotes.\n")
    print(cl(string_one + "\n", "cyan"))
    print(cl(string_two + "\n", "green"))
    print(cl(string_three, "blue"))

    del hold
Example #24
0
def fizzBuzz(start, stop):

    #Create a file to hold the answer
    file = open('fizzBuzz.txt', "w")

    for i in range(int(start), int(stop) + 1):

        if (i % 3 == 0) and (i % 5 != 0):
            file.write('Fizz\n')
            print(cl('Fizz', 'red'))
        elif (i % 5 == 0) and (i % 3 != 0):
            file.write('Buzz\n')
            print(cl('Buzz', 'blue'))
        elif (i % 3 == 0) and (i % 5 == 0):
            file.write('FizzBuzz\n')
            print(cl('FizzBuzz', 'magenta'))
        elif (i % 3 != 0) and (i % 5 != 0):
            file.write(str(i))
            file.write('\n')
            print(str(i))

    file.close()
def taskTwo():
    """
    Write a program that prints a message if a variable
    is less than 10, and a different message if a variable
    is greater than or equal to 10.
    """

    strLess = "Books are a uniquely portable magic. ~ Stephen King"
    strGrtTen = """\tMemories warm you up from the inside. 
                But they also tear you apart. ~ Haruki Murakami"""

    pick = input("Please pick a number from 0 to 20 to get a quote: ")

    checker = [str(i) for i in range(0, 21)]

    if pick in checker:
        print(
            cl(strLess, "cyan") if int(pick) < 10 else cl(strGrtTen, "green"))
    else:
        print(cl("Please try again!\n", "red"))
        taskTwo()

    del checker
Example #26
0
def wordADay():
    
    nary = "https://www.dictionary.com/e/word-of-the-day/"
    naryClient = req(nary)
    site_parse_nary = soup(naryClient.read(), "lxml") 
    naryClient.close()
    
    #Pull from 'Word of the Day' wrapper
    wordDayCase = site_parse_nary.find("div", {"class": "wotd-item-wrapper"})
    #Pull the word itself
    wordDay = wordDayCase.find("div", {"class": "wotd-item-headword__word"}).text.strip()
    #Pull the pronunciation 
    wordSpeak = wordDayCase.find("div", {"class": "wotd-item-headword__pronunciation"}).text.strip()
    #Pull the definition 
    wordMean = wordDayCase.find("div", {"class": "wotd-item-headword__pos-blocks"})
    wordType = wordMean.find("span").text.strip()
    wordDef = wordMean.findAll("p")[1].text.strip()
    
    print(cl(wordDay, "blue"))
    print(cl(wordSpeak, "red"))
    print(cl("----------------------", "grey"))
    print(cl("Word type: " + wordType, "cyan"))
    print(cl(wordDef, "blue"))
Example #27
0
def deustchesWort():
    
    dicttu = "https://dict.tu-chemnitz.de/dings.cgi?o=3020;service=deen;random=en"
    dictClient = req(dicttu)
    site_parse_deutsch = soup(dictClient.read(), "lxml")
    dictClient.close()
    
    #Pull a subject in order to find a word
    subDeutsch = site_parse_deutsch.find("div", {"class": "result"}).find("table", {"id": "result"})
    wortAlles = subDeutsch.find("tbody", {"id": "h1"}).find("tr", {"class": "s1"}).text.strip()
    wort = wortAlles.split('\n')[0]
    wortDef = wortAlles.split('\n')[1]
        
    print(cl("Deutsches Wort: ", "yellow"))
    print(cl(wort, "blue"))
    print(cl("auf Englisch: " + wortDef, "red"))
    #In case a search is incomplete or not found
    try:
        wortInfo = wiki.summary(wortDef,sentences=2, auto_suggest=False)
    except:
        print("Page not found for English entry")
    else:
        print(cl(wortInfo, "green"))
Example #28
0
def info(datne):
    print(cl("\n\nInformācija par datni " + datne, 'green', attrs=['reverse']))
    # # importējam datus
    # # df is saīsinajums no Data Frame,
    # # Pandas bibliotēkas pamata datu struktūras
    df = pd.read_csv(datne)
    # # apskatīt pirmās 5 datu rindiņas
    print(cl("\nPirmās 5 rindiņas", attrs=['bold']))
    print(df.head(5))
    # # aplūkojam kolonnu nosaukumus
    # print(cl("\nKolonnu nosaukumi", attrs = ['bold']))
    # print(df.columns)

    # # aplūkojam statistisku informāciju
    # print(cl("\nStatistika", attrs = ['bold']))
    print(df.describe())

    # print(cl("\nDatu tipi", attrs = ['bold']))
    # aplūkojam datu tipus
    # print(cl(df.dtypes, attrs = ['bold']))

    # # parāda, kur datos ir tukšas vērtības
    # print(cl("\nTukšas vērtības datos", attrs = ['bold']))
    print(df.isnull().sum())
def main():

    #Let the user pick a task which will
    #return that task's solution

    print(
        cl(
            "Welcome! This program prints out the solutions " +
            "of the challenges section in Chapter Three " +
            "of Cory Althoff's The Self-Taught Programmer. ", "blue"))

    task = input(
        cl("Please choose a task by typing" + "in a number from 1 to 6: ",
           "blue"))

    check = [str(i) for i in range(1, 7)]

    if task in check:
        print(
            cl("Thank you for choosing a task! The solution will now print.",
               "magenta"))
        if task == check[0]:
            taskOne()
        elif task == check[1]:
            taskTwo()
        elif task == check[2]:
            taskThree()
        elif task == check[3]:
            taskFour()
        elif task == check[4]:
            taskFive()
        elif task == check[5]:
            taskSix()
    else:
        print(cl("Please choose a number between 1 to 6!", "red"))
        main()
Example #30
0
def main():
    load()
    while True:
        sys.stdout.write(cl('>>>', 'blue') + ' ')
        line = sys.stdin.readline().strip('\n').split()
        if (len(line) == 0):
            continue
        if (line[0] == ':quit'):
            return

        try:
            execute(line)
            save()
        except Exception as e:
            print e
def taskFour():
    #Create a program that divides two variables and prints the remainder

    print(
        cl(
            "Choose two numbers and we shall return the " +
            "remainder from its division.", "magenta"))

    num_one = input("Choose a dividend: ")
    num_two = input("Now, choose a divisor: ")

    remainder = int(num_one) % int(num_two)
    print("\n")
    print(num_one + " divided by " + num_two + " returns a remainder of " +
          str(remainder))
def taskFive():
    #Create a program that takes two variables, divides them, and prints
    #the quotient

    print(
        cl(
            "Choose two numbers and we shall return the " +
            "quotient from its division.", "magenta"))

    num_one = input("Choose a dividend: ")
    num_two = input("Now, choose a divisor: ")

    quotient = int(num_one) / int(num_two)
    print("\n")
    print(num_one + " divided by " + num_two + " returns a quotient of " +
          str(quotient))
def main():
    if len(sys.argv) < 3:
        ievade()
    else:
        parser = argparse.ArgumentParser(
            prog='autocena',
            description=
            """Nosaka auto cenu, izmantojot uz reāliem datiem trenētu modeli"""
        )
        parser.add_argument('gads')
        parser.add_argument('tilpums')
        parser.add_argument('nobraukums')
        args = parser.parse_args()
        print(args)
        dati = [[args.gads, args.tilpums, args.nobraukums]]
        modelis = ieladet_modeli("ss-modelis.pickle")
        prognoze = prognozejam_rezultatu(modelis, dati)
        print("Prognozētā cena:",
              cl(round(prognoze[0]), "green", attrs=["bold"]))
Example #34
0
for i in df.columns:
    df[i] = df[i].astype(int)

df.head()

df.describe()

df.info()

# Splitting the data

X_var = np.asarray(
    df[['tenure', 'age', 'income', 'ed', 'employ', 'longmon', 'custcat']])
y_var = np.asarray(df['churn'])

print(cl('X_var samples : ', attrs=['bold']), X_var[:5])
print(cl('y_var samples : ', attrs=['bold']), y_var[:5])

X_var = StandardScaler().fit(X_var).transform(X_var)

print(cl(X_var[:5], attrs=['bold']))

X_train, X_test, y_train, y_test = train_test_split(X_var,
                                                    y_var,
                                                    test_size=0.3,
                                                    random_state=4)

print(cl('X_train samples : ', attrs=['bold']), X_train[:5])
print(cl('X_test samples : ', attrs=['bold']), X_test[:5])
print(cl('y_train samples : ', attrs=['bold']), y_train[:10])
print(cl('y_test samples : ', attrs=['bold']), y_test[:10])
Example #35
0
# IMPORTING DATA

df = pd.read_csv('Dataset.csv')
df.drop('Time', axis = 1, inplace = True)

print(df.head())

# Count & percentage

cases = len(df)
nonfraud_count = len(df[df.Class == 0])
fraud_count = len(df[df.Class == 1])
fraud_percentage = round(fraud_count/nonfraud_count*100, 2)

print(cl('CASE COUNT', attrs = ['bold']))
print(cl('--------------------------------------------', attrs = ['bold']))
print(cl('Total number of cases are {}'.format(cases), attrs = ['bold']))
print(cl('Number of Non-fraud cases are {}'.format(nonfraud_count), attrs = ['bold']))
print(cl('Number of Non-fraud cases are {}'.format(fraud_count), attrs = ['bold']))
print(cl('Percentage of fraud cases is {}'.format(fraud_percentage), attrs = ['bold']))
print(cl('--------------------------------------------', attrs = ['bold']))

# Description

nonfraud_cases = df[df.Class == 0]
fraud_cases = df[df.Class == 1]

print(cl('CASE AMOUNT STATISTICS', attrs = ['bold']))
print(cl('--------------------------------------------', attrs = ['bold']))
print(cl('NON-FRAUD CASE AMOUNT STATS', attrs = ['bold']))
Example #36
0
 def __repr__(self):
   return "{'db/id': %s}" % cl(self._eid, 'magenta')