DEV Community: shrish

Block Chain

shrish — Wed, 30 Mar 2022 04:07:23 +0000

Over the past few years, you have consistently heard the term ‘blockchain technology,’ probably regarding cryptocurrencies, like Bitcoin. In fact, you may be asking yourself, “what is blockchain technology?” It seems like blockchain is a platitude but in a hypothetical sense, as there is no real meaning that the layman can understand easily. It is imperative to answer “what is blockchain technology, “including the technology that is used, how it works, and how it’s becoming vital in the digital world.

As blockchain continues to grow and become more user-friendly, the onus is on you to learn this evolving technology to prepare for the future. If you are new to blockchain, then this is the right platform to gain solid foundational knowledge. In this article, you learn how to answer the question, “what is blockchain technology?” You’ll also learn how blockchain works, why it’s important, and how you can use this field to advance your career.

Blockchain technology is a structure that stores transactional records, also known as the block, of the public in several databases, known as the “chain,” in a network connected through peer-to-peer nodes. Typically, this storage is referred to as a ‘digital ledger.’

Every transaction in this ledger is authorized by the digital signature of the owner, which authenticates the transaction and safeguards it from tampering. Hence, the information the digital ledger contains is highly secure.

In simpler words, the digital ledger is like a Google spreadsheet shared among numerous computers in a network, in which, the transactional records are stored based on actual purchases. The fascinating angle is that anybody can see the data, but they can’t corrupt it.Suppose you are transferring money to your family or friends from your bank account. You would log in to online banking and transfer the amount to the other person using their account number. When the transaction is done, your bank updates the transaction records. It seems simple enough, right? There is a potential issue which most of us neglect.

These types of transactions can be tampered with very quickly. People who are familiar with this truth are often wary of using these types of transactions, hence the evolution of third-party payment applications in recent years. But this vulnerability is essentially why Blockchain technology was created.

Technologically, Blockchain is a digital ledger that is gaining a lot of attention and traction recently. But why has it become so popular? Well, let’s dig into it to fathom the whole concept.

Record keeping of data and transactions are a crucial part of the business. Often, this information is handled in house or passed through a third party like brokers, bankers, or lawyers increasing time, cost, or both on the business. Fortunately, Blockchain avoids this long process and facilitates the faster movement of the transaction, thereby saving both time and money.

Most people assume Blockchain and Bitcoin can be used interchangeably, but in reality, that’s not the case. Blockchain is the technology capable of supporting various applications related to multiple industries like finance, supply chain, manufacturing, etc., but Bitcoin is a currency that relies on Blockchain technology to be secure.

Types of Blockchain
There are four different types of blockchains. They are as follows:

Private Blockchain Networks
Private blockchains operate on closed networks, and tend to work well for private businesses and organizations. Companies can use private blockchains to customize their accessibility and authorization preferences, parameters to the network, and other important security options. Only one authority manages a private blockchain network.

Public Blockchain Networks
Bitcoin and other cryptocurrencies originated from public blockchains, which also played a role in popularizing distributed ledger technology (DLT). Public blockchains also help to eliminate certain challenges and issues, such as security flaws and centralization. With DLT, data is distributed across a peer-to-peer network, rather than being stored in a single location. A consensus algorithm is used for verifying information authenticity; proof of stake (PoS) and proof of work (PoW) are two frequently used consensus methods.

Permissioned Blockchain Networks
Also sometimes known as hybrid blockchains, permissioned blockchain networks are private blockchains that allow special access for authorized individuals. Organizations typically set up these types of blockchains to get the best of both worlds, and it enables better structure when assigning who can participate in the network and in what transactions.

Consortium Blockchains
Similar to permissioned blockchains, consortium blockchains have both public and private components, except multiple organizations will manage a single consortium blockchain network. Although these types of blockchains can initially be more complex to set up, once they are running, they can offer better security. Additionally, consortium blockchains are optimal for collaboration with multiple organizations.

Advantages
One major advantage of blockchains is the level of security it can provide, and this also means that blockchains can protect and secure sensitive data from online transactions. For anyone looking for speedy and convenient transactions, blockchain technology offers this as well. In fact, it only takes a few minutes, whereas other transaction methods can take several days to complete. There is also no third-party interference from financial institutions or government organizations, which many users look at as an advantage.

Disadvantages
Blockchain and cryptography involves the use of public and private keys, and reportedly, there have been problems with private keys. If a user loses their private key, they face numerous challenges, making this one disadvantage of blockchains. Another disadvantage is the scalability restrictions, as the number of transactions per node is limited. Because of this, it can take several hours to finish multiple transactions and other tasks. It can also be difficult to change or add information after it is recorded, which is another significant disadvantage of blockchain.

Making a password protected Virtual Journal using Tkinter,python

shrish — Sat, 04 Sep 2021 13:31:44 +0000

Introduction:

With help of Python i have tried to recreate the joy of maintaining a journal(Virtually).People often don't find time for maintaining a physical diary or journal these days.This Virtual Journal will serve them well and good as it is as effective as a physical one.The password protection feature gives the privilage of opening the application only by the user.(I have written this blog with the assumption that you have basic knowledge about tkinter and python;If not learn and revisit the blog.)

Modules Used:

The main modules used are "Tkinter"(For creating GUI),"os"(For openig files).Additional to these i have created three(user defined) modules namely "write_func","read_func","edit_func" to perform desired operations.

Explanation of the Code Structure:

I have splited this whole program into four different files(three user defined custom modules and one main program).

Main Program:

The main program contains the Password protection feature and it serves as a base for our project ,by importing other user-defined modules.The code for the main program is the following:(I have explained it's function line by line within the code please do refer)

#Modules used 
 #These modules are inbuilt python modules.
from tkinter import*
from tkinter import messagebox
import os
import time

#These modules are user defined python modules.Each module has its own function.
import write_func
import read_func
import edit_func

def directory():
    '''This function sets the directory to the defined path.This path 
    is where all your files will be saved.'''
    path="#path"
    os.chdir(path)
directory()

class login_interface(Frame):
    '''This class contains the login section of the app.The user have 
    to enter a password to access the main application.'''
    def __init__(self,master=None):
        #initiating the frame
        Frame.__init__(self,master)
        self.master=master
        self.security()

    #function that holds the widgets of login window
    def security(self):
        self.master.title("LOGIN")
        self.pack(fill=BOTH, expand=1)
        lbl = Label(self, text="PASSWORD").grid(column=0, row=0)

        # Entry to get a input from the user
        self.pwrd = Entry(self,show="*")
        self.pwrd.focus_set()
        self.pwrd.grid(column=1, row=0)

        #login button binded to a function named login
        login = Button(self, text="login", width=20,command=self.login)
        login.grid(column=1, row=2)


    def login(self):
        '''this function which is binded to the "login" Button checks if the
        password given by the user.If it is correct it directs the user to main application'''

        #if the password given is correct the following get executed
        if self.pwrd.get()=="#Your_password":
            #destroys the present login window
            a.destroy()

            #initiates the main application
            b=Tk()
            b.geometry("500x500")
            app_b=journal(b)  #journal is a class mention bellow
            app_b.mainloop()  #mainloop for the program should run until we close
                              #Note  this is the mainloop of our main application

        #if the given password is wrong then an error is shown
        else:
            messagebox.showinfo("ERROR ","retry wrong password")

class journal(Frame):
    '''this class contains the frame and widgets which make up the main application.
    Main application contains three buttons Write,read,Edit respectively.'''

    #initating frame of window
    def __init__(self,master=None):
        Frame.__init__(self,master)
        self.master=master

        self.master.title("DIARY")
        self.pack(fill=BOTH, expand=1)

        #write button binded to write function.
        write_button=Button(self,text="Write",width=100,height=10,command=self.write)
        write_button.pack()

        #Read button binded to read function.
        read_button=Button(self,text="Read",width=100,height=10,command=self.read)
        read_button.pack()

        #Edit button binded to edit function.
        edit_button=Button(self,text="Edit",width=100,height=10,command=self.edit)
        edit_button.pack()

    def write(self):
        '''this function calls the function defined in the "write_func" module.This module is an user defined module.
        This module enables user to write their thoughts and save it in the respective directory.'''

        a=Tk()
        B=write_func.window(a)
        B.mainloop()

    def read(self):
        '''This function calls the function defined in the "read_func" module.This module is an user defined module.
        This module enables user to read the files they have saved previously.'''

        a=Tk()
        B=read_func.window(a)
        B.mainloop()        

    def edit(self):
        '''this function calls the function defined in the "edit_func" module.This module is an user defined module.
        This module enables the user to revisit and edit the files they have saved previously.'''

        a=Tk()
        B=edit_func.window(a)
        B.mainloop()


'''Creating the instance of the login class and running the program'''
a=Tk()
a.geometry("250x50")
app=login_interface(a)
app.mainloop()

Output of this code will be like this:

After entering the proper password the main application will open

As you can see the main application contains three buttons namely,"Write","Read","Edit".
The "Write" button is bound to the "write_func" module.
similarly the "Read" and "Edit" button is bound to "read_func" and "edit_func" modules respectively.

write_func:

This modules opens up an GUI allowing the user to write(type) down his/her thoughts and save it as ".txt" file in the location(within the local device) specified by the user.The following is the code for this module:

#moules imported
from tkinter import*
import time
import os
from tkinter import messagebox

def directory():
    '''This function sets the directory to the defined path.This path 
    is where all your files will be saved.'''
    path="#Path"
    os.chdir(path)
directory()



class window(Frame):
    '''This class contains the widgets that will allow user to write into files'''
    def __init__(self,master=None):
        #intialisation of the frame
        Frame.__init__(self,master)
        self.master=master
        self.master.title("Diary")
        title=Label(self.master,text="Title").pack()

        #Entry box to get titile of the file from the user.
        self.title_box=Entry(self.master)
        self.title_box.pack()

        scrollbar=Scrollbar(self.master).pack(side=RIGHT,fill=Y)#scrollbar
        Label(self.master,text="Content").pack()

        #Text for the user to write his thoughts
        self.content_box=Text(self.master)
        self.content_box.pack()

        #This button is binded to the function "save_file" wich saves the file in the specified path'''
        save_button=Button(self.master,text="Save",width=10,command=self.save_file).pack()

    def save_file(self):
        '''This function saves the content written by the user as a text file'''

        localtime=time.asctime(time.localtime(time.time()))
        date=localtime[8:11]
        month=localtime[4:7]
        year=localtime[20:24]
        file_name=self.title_box.get()+" "+date+month+year+".txt"
        f=open(file_name,"w+")
        f.write(self.content_box.get("1.0",END))
        messagebox.showinfo("Diary","Your file is saved successfully!! ")

When the "Write" button in the main application is pressed it will generate the following output:

read_func:

This module generates a interface which allows the user to open and read his/her previous wrtings.The following is the code for this:

#modules imported
from tkinter import*
import os
from tkinter import messagebox


class window(Frame):
    '''This class contains the widgets that allows the user to read the files stored previously'''
    def __init__(self,master=None):
        #intilisation of the frame
        Frame.__init__(self,master)
        self.master=master
        self.master.title("Diary")
        self.master.geometry("400x300")

        #Display all the files present in the directory
        Label(self.master,text="Select a file").pack(side=TOP)
        path="#path"
        self.file_names=os.listdir(path)
        self.srch_box=Entry(self.master)
        self.srch_box.pack()
        file_list=Listbox(self.master)
        file_list.pack()
        for i in range(0,len(self.file_names)):
            a=str(i+1)+") "+self.file_names[i]
            file_list.insert(END,a)

        #Read button binded to the function "read_file" which displays the content in the file.
        read_button=Button(self.master,text="Read",width=20,command=self.read_file).pack(side=BOTTOM)
    def read_file(self):
        self.file_name=self.srch_box.get()

        '''If the specified file is present it is displayed in a text
         for the user to read.If the specified file is not present it 
         displays an error'''
        if(self.file_name in self.file_names ):
            f=open(self.file_name,"r")
            contents=f.read()
            read_window=Tk()
            read_window.title(self.file_name)
            t=Text(read_window)
            t.pack()
            t.insert("end",contents)
            t.config(state=DISABLED)
            read_window.mainloop()
        else:
            messagebox.showinf0("Diary","File doesn't exist")

When the "Read" button in the main application is pressed it will generate the following output:

When the user enters the file name which he/she desires to read it will be displayed to him/her in this manner:

edit_func:

This modules allows the user to revisit any files and edit the content in it.The code for this is the following:

#Modules imported
from tkinter import*
import os
from tkinter import messagebox


class window(Frame):
    '''This class contains the widgets that allows the user to edit the file saved previously'''

    def __init__(self,master=None):
        #intitialsation of frame
        Frame.__init__(self,master)
        self.master.title("Diary")
        self.master.geometry("400x300")

        #Diplaying the files in the path for the user to select.
        Label(self.master,text="Select a file").pack()
        path="C:/Users/Dhanalakshmi/journal"
        self.file_names=os.listdir(path)
        self.srch_box=Entry(self.master)
        self.srch_box.pack()
        file_list=Listbox(self.master)
        file_list.pack()
        for i in range(0,len(self.file_names)):
            a=str(i+1)+") "+self.file_names[i]
            file_list.insert(END,a)

        #Edit button binded with "edit_File" function which allows user to edit the selected file.
        edit_button=Button(self.master,text="Edit File",width=20,command=self.edit_file).pack()


    def edit_file(self):
        '''This function opens the file specified by the user to edit it.If the file is not present then it shows an error '''
        self.file_name=self.srch_box.get()
        if(self.file_name in self.file_names ):
            f=open(self.file_name,"r")
            content=f.read()
            edit_window=Tk()
            t=Text(edit_window)
            t.pack()
            edit_window.title(self.file_name)
            t.insert("end",content)

            #Saves the edited file.
            def save_file():
                F=open(self.file_name,"w+")
                F.write(t.get("1.0",END))
                messagebox.showinfo("Diary","Your file is saved successfully")
            save_button=Button(edit_window,text="Save",command=save_file).pack()
        else:
            messagebox.showinfo("Diary","File doesn't exist")

When the "Edit" button in the main application is pressed it will generate the following output:

When the user enters the file name which he/she desires to edit it will be displayed to him/her in this manner:

Makesure that these user defined modules are defined in the same directory as of the main program.I have also given the github repo link of this project.Following the specified instructions you will be able to create a simple "Virtual Password Protected Journal" application.
Thank you for takin' time to read my blog,if you have any queries mention it in the comments.

Github Link: https://github.com/MSHRISH/Digital-Diary

Making a simple voice controlled personal assistant interface using python

shrish — Fri, 04 Dec 2020 05:44:06 +0000

I'm using tkinter,a python module, to create the Graphical User Interface(GUI) in which our application is gonna be wrapped in.

This project is a mere try to produce a simple version of Windows Cortana using python.Though my application may not be as robust as Cortana it could perform some functions that Cortana would.

The final product would be like this:

As you can see the interface contains a button("listen") which turns on the mike of your system to recognize your speech and process your query.

Actions that could be performed:

1)Greets user when he/she greets
2)Informs time,date and month to the user when he/she demands it.
3)Opens web browsers and search pharses specified by user.
4)Opens Youtube and searches the video specified by the user.
5)Opens Wikipedia and searches the term specified by the user.

Modules used:-

1)Tkinter to create GUI
2)Pyttsx3 to convert text to synthetic voice
3)Speech Recognition and Pyaudio to recognize speech input from user
4)Time module
5)"Random" module
6)selenium to open webdriver and automate search engine
Make sure the modules are installed in your machine.
Assuming that you know the fundamentals of these modules I write this article.

Code Architecture:

In order to keep things simple I created a giant class and instance of the class.Within the class I defined every method required.The class contains 5 parts.

The first part is an init function which defines our GUI
and wraps the button inside it.
The second part contains a method which converts text to speech.
The third part contains a method which recognizes speech from user and returns text.
The fourth part is not just one function but a bunch of functions each with it's own functionality(such as a function to greet the user,search web browser,fetch time and date).
The fifth and last part of the class is a method defined to process the input given by the user and to give desired output.

Alright let's get started with the code!!

Importing modules:-

#Modules used
from tkinter import*
import pyttsx3
import speech_recognition as sr
import pyaudio
import random
import time
from tkinter import messagebox
from selenium import webdriver
from selenium.webdriver.common.keys import Keys

Defining the class:-

Having imported the modules we shall start creating the class.

#Main class

class Window(Frame):
    #defining our main window
    def __init__(self,master):
        self.master=master
        master.title("DREAM")
        A=Label(master,text="try saying *what can you do*")
        A.pack(side="top")
        Button(master,text="listen",width=100,relief="groove",command=self.Processo_r).pack(side="bottom")

root=Tk()
#instance of the class  
app=Window(root)
root.geometry("300x50")
#Runs the application until we close
root.mainloop()

This class defines a GUI window with a text saying "try saying what can you do" and a button.Note that the button has an attribute named "command" which is linked with a class method.It means that when the button is pressed the "self.processo_r" method(which will be defined further) gets executed.

The upcoming methods are defined inside the class

Defining method to convert text to speech:

 def speak(self,output):
        #initiating the speech engine
        engine = pyttsx3.init()
        #speaking the desired output 
        engine.say(output)
        engine.runAndWait()

In order to convert text to speech i'm using Pyttsx3 module.The method has one parameter output which will be spoken by the synthetic voice.

Method to recognize speech and convert it to text:

    def speech_recog(self):
        #recognizer class
        r=sr.Recognizer()
        #Specifing the microphone to be activated
        mic = sr.Microphone(device_index=1)

        #listening to the user 
        with mic as s:
            audio = r.listen(s, timeout=5)
            r.adjust_for_ambient_noise(s)

        #Converting the audio to text  
        try:
            """I use google engine to convert the speech 
             text but you may use other engines such as 
             sphinx,IBM speech to text etc."""
            speech = r.recognize_google(audio)
            return speech

        """When engine couldn't recognize the speech 
        throws this"""
        except sr.UnknownValueError:
            #calling the text to speech function
            self.speak("please try again,couldnt identify")

        """This error shows up when the microphone cant 
        pick up any speech"""
        except sr.WaitTimeoutError as e:
            self.speak("please try again")

I use speech Recognition module to recognize speech and to convert it to text.This function when called turns on the microphone and recognizes the speech.Then it converts it to text and returns it.

Now that i have defined three parts of the class i might as well start defining methods with specific functions.

Method to greet the user:

    def greet(self):
       #greets the user with a random phrase from A
        A=["Hi,nice to meet you","hello","Nice to meet you","hey,nice to meet you","good to meet you!"]
        b=random.choice(A)
        self.speak(b)

Method to tell time

    def tell_time(self):
        localtime = time.asctime(time.localtime(time.time()))
        a = localtime[11:16]
        self.speak(a)

This method uses time module to get local time of the user's device and informs the user when asked.

Method to tell day of the week:

    def tell_day(self):
        localtime = time.asctime(time.localtime(time.time()))
        day = localtime[0:3]
        if day == "Sun":
            self.speak("it's sunday")
        if day == "Mon":
            self.speak("it's monday")
        if day == "Tue":
            self.speak("it's tuesday")
        if day == "Wed":
            self.speak("it's wednesday")
        if day == "Thu":
            self.speak("it's thursday")
        if day == "Fri":
            self.speak("it's friday")
        if day == "Sat":
            self.speak("it's saturday")

This method uses time module to get day of the week and informs the user when asked.

Method to tell month of the year:


 def tell_month(self):
        localtime = time.asctime(time.localtime(time.time()))
        m_onth = localtime[4:7]
        if m_onth == "Jan":
            self.speak("it's january")
        if m_onth == "Feb":
            self.speak("it's february")
        if m_onth == "Mar":
            self.speak("it's march")
        if m_onth == "Apr":
            self.speak("it's april")
        if m_onth == "May":
            self.speak("it's may")
        if m_onth == "Jun":
            self.speak("it's june")
        if m_onth == "Jul":
            self.speak("it's july")
        if m_onth == "Aug":
            self.speak("it's august")
        if m_onth == "Sep":
            self.speak("it's september")
        if m_onth == "Oct":
            self.speak("it's october")
        if m_onth == "Nov":
            self.speak("it's november")
        if m_onth == "Dec":
            self.speak("it's december")

This method uses time module to get month of the year and informs the user when asked.

Method to search phrases in web browser:

    def search(self,web_name):
        self.speak("Searching")
        """Make sure that you have installed the specific driver 
        for your webbrowser.The executable_path could be different for you"""

        #Opeing the driver
        driver = webdriver.Chrome(executable_path="C:\Program Files (x86)\chromedriver.exe")

        #Navigating to google
        driver.get('https://www.google.com/')

        #Locating the search engine
        search_engine = driver.find_element_by_name("q")

        #Search the phrase(web_name) and hitting enter to show results
        search_engine.send_keys(web_name + Keys.ENTER)

I have used Selenium for searching the phrase specified by the user.As i have said before make sure you know the fundamentals of the specified modules.Using similar algorithm with some minor changes let's create a method to open google chrome,search Youtube videos and wikipedia articles.

Method to Open Chrome:

    def open_chrome(self):
        self.speak("opening chrome")
        driver=webdriver.Chrome(executable_path="C:\Program Files (x86)\chromedriver.exe")
        driver.get("https://www.google.com/")

Method to search Youtube videos

     def play_tube(self, vid_name):
        self.speak("Searching youtube")

        #intializing driver
        driver = webdriver.Chrome(executable_path="C:\Program Files (x86)\chromedriver.exe")

        #navigating to Youtube
        driver.get('https://www.youtube.com/')

        #Locating the Youtube search engine
        search_engine = driver.find_element_by_name("search_query")

        # searching the specified video
        search_engine.send_keys(vid_name + Keys.ENTER)

I have used the same algorithm which I used to search google to search youtube.The main difference is the driver navigates to google in the former and youtube in the latter.

Method for searching article in wikipedia

    def search_wiki(self, article):

        #intializing driver
       driver=webdriver.Chrome(executable_path="C:\Program Files (x86)\chromedriver.exe")

        #Navigating to Wikipedia
       driver.get("https://www.wikipedia.org/")

        #Locating the wikipedia search engine
       search_engine=driver.find_element_by_name("search")

       #Searching the specified phrase
       search_engine.send_keys(article+Keys.ENTER)

Method which displays a list containing all possible operations the application supports

 def functions(self):
        self.speak("here is a list of what i can do")
        messagebox.showinfo("DREAM functions", "1.Try saying 'Hi','Hello'" +
                            "\n2.Try asking 'What day is this?'" +
                            "\n3.Try asking 'What month is it?'" +
                            "\n4.Try asking 'What time is it?'" +
                            "\n5.You search in google by saying...'Search (or) Google <anything>'" +
                            "\n6.Play youtube by saying'YouTube... <video_name>'" +
                            "\n7.Search in Wikipedia by saying...'wikipedia...<anything>'" +
                            "\n8.To close say 'Bye' or 'Sleep' or 'See you later'")

Method to quit the application:

    def shut(self):
        #bids the user goodbye and quits
        A=random.choice(["bye", "good bye", "take care bye"])
        self.speak(end_greet)
        exit()

Defining a method to process the input:

    def Processo_r(self):
        speech=str(self.speech_recog())

        if speech=="What can you do":
            self.functions()   


        A=["hi","hello","hey","hai","hey dream""hi dream","hello dream"]
        if speech in A:
            self.greet()

        if speech =="who are you":
            self.speak("i'm dream")
            self.speak("your personal assistant")

        B=["what day is it","what day is today","what day is this"]
        if speech in B:
            self.tell_day()

        C=["what month is it","what month is this"]
        if speech in C:
            self.tell_month()

        D=["what time is it","what is the time","time please",]
        if speech in D:
            self.tell_time()

        if speech[0:6] =="Google":
            self.search(speech[7:])

        if speech[0:7]=="YouTube":
            self.play_tube(speech[8:])

        if speech=="open Chrome":
            self.open_chrome()

        if speech[0:9]=="Wikipedia":
            self.search_wiki(speech[10:])

        E=["bye","bye dream","shutdown","quit"]
        if speech in C:
            self.shut()
        else:
            self.speak("I am sorry couldn't perform the task you specified")

This method gets executed when we press the Listen button in the interface.It calls the speech_recog function that we defined before and stores the returned text.Then it analyses the text with a series of "if" conditions and gives the user desired output.

After putting together the code the application should be working perfectly.Make sure you are connected to internet.You can also add some new methods to the class which performs something that pleases you!

Thank you for reading:-).
If you have any queries let me know by posting it in discussion.