DEV Community: codesharedot

Trying out KDE

codesharedot — Wed, 06 Nov 2019 21:16:48 +0000

Trying out the KDE Plasma desktop. Compared to the earlier KDE versions it's improved a lot.

The search menu that's in the start menu is very good. Any modern desktop or window manager doesn't work well without a good search option.

Compared to LxQt the feel is quite similar. It just has more features than LxQt. There's a demo of the KDE plasma desktop here:

Install KDE

If you want to try it out, you can install Kubuntu (an ubuntu variant) or install it from the terminal

    $ sudo apt install tasksel
    $ sudo tasksel install kubuntu-desktop

That's it, now logout and login again.

UX

Overall it does the job, not a fan of the Konsole, so switched over to another terminal emulator. The konsole looks like this:

well, I prefer somethign like this:

But as for the desktop, doesn't matter much.

The memory usag is quite low, 256MB memory use. In an age where you can easily get a few gigs of memory, that's nothing.

Related links:

Little Linux Flashback (90s)

codesharedot — Mon, 04 Nov 2019 22:32:21 +0000

I started using Linux over 15 years ago. The Linux system (Most often use the terms Linux distributions, because technically Linux is only the kernel) experience has changed a lot over the years.

To give you some perspective, we used these type of computers:

This was in a time, when Linux did not have any USB support, no wireless network support. You'd plugin the CD (if you had one), and end up in a terminal like this (Slackware Linux):

Configuration drama

Then after installing, you'd find out you are still in a terminal. You had to configure this thing called X. You'd run the command xf86config, with which you could configure your graphical settings (screen resolution et al).

But, after doing this, it still would not work. Then you'd run this command many times over trying to get the right settings. After that finally worked (day later), you'd feel happy.

More trouble ahead

Then you'd end up with an antique Gnome desktop. But now, the sound card doesn't work. Again, you spend many hours trying to figure out how that works. Now you have to compile the kernel to include the sound card driver, oh dear.

What's that, you want wireless support? Get ready to compile the kernel yet again! If you are lucky, it won't show the message Kernel Panic.

Modern day Linux

The modern day Linux distribution is much smoother! For most modern Linux distributions, everything works out of the box, including the desktop environment, all the drivers and everything else.

The only trouble I've run into is this "Secure Boot / UEFI" stuff. But that can easily be solved.

You can easily end up with a desktop like this (or any of the others like Gnome, KDE)

What's your Linux experience been Like? Is this the year of the Linux desktop? :P

Some more Linux links stuff:

What do you automate in your life and work?

codesharedot — Mon, 28 Oct 2019 10:12:04 +0000

What do you automate in your life and work?

I've setup birthday reminders, for birthday reminders I use simple email calendar notifications instead of cronjob.

Using Zsh over bash, as tab competion and searching commands much easier.

Best Python framework for building a desktop application and GUI

codesharedot — Fri, 25 Oct 2019 15:17:04 +0000

Python has been the most trending programming language used for object oriented progamming. With python you can run simple statement over and over again without having to compile a whole program of which it's output functionality is superb.

Of course, Python is an interactive programming which has a diverse range of options for GUI (Graphical User Interface) framework (help developers create GUI applications in an easy and secure manner). This article discusses the Best Python framework for building a desktop application and GUI.

NB: It is essential that you have a basic knowledge of Python programming language before you can use these python frameworks.

Let's delve it to the discus

PyQT

PyQt is a Graphical User Interface widget toolkit. It is one of the most powerful and popular Python interfaces. It is a combination of the Qt (owned by Nokia) library and Python programming language which leaves a developer to decide whether to create a program by coding or create visual dialogs using Qt Designer.

PyQt is a free Python bindings software open-source widget-toolkit Qt, implemented for cross-platform application development framework. In the free version, certain features may not be available but if your application is open source then you can use it under a free license.

PyQt is available on Windows, MacOSX, Linux, Android iOS and Raspberry Pi and different python versions ranging from v2 to Qt v5.

Tkinter

Tkinter is the most popular programming package for graphical user interface or desktop apps. It is so named because of its simplicity. Tkinter is the combination of Tk and Python's standard GUI framework.

TKinter comes with an abundance of resources of codes and reference books which is the major merit of choosing it as a package. It provides diverse widgets, such as labels, buttons, and text boxes used in a graphical user interface application. The Button control also called widgets are used to display buttons in developed application while the Canvas widget is used to draw shapes (lines, ovals, polygon...) in your application.

It is easy to get help when you come across a hurdle in the course of developing your application since Tkinter has thousands of users because it has been in use for a very long time. Tkinter is an open source and it is available under the Python License.

Kivy

Kivy as an OpenGL ES 2 accelerated framework for the creation of new user interfaces empowers you with the ease to write your code once and have it run on different platforms or Operating Systems (Windows, MacOSX, Linux, Android iOS and Raspberry Pi).

Kivy apps creation is fun, easy and rewarding because it is free and is an open source Python library for creating application software with an enabled natural user interface . Kivy comes twenty widgets in its toolkit.

Python kivy

WxPython

WxPython is a python extension module. It is also an open source wrapper for cross-platform graphical user interface library Widget.

As a developer, you can develop traditional applications for Windows, Unix and Mac OS.

PyGUI

PyGUI is the simplest and most lightweight of all GUIs because it is purely in sync with Python programming language. It is a cross-platform graphical application framework for Windows, Mac OS, and Unix.

A PyGUI developer inserts very less code between the GUI platform and Python application which in turn displays the natural GUI of the platform.

PyGui tutorial

Summary

The above listed are the most widely used and best Python graphical user interface frameworks available. It's up to the developer to choose the Python GUI framework that best suits him/her.

Bitcoin price with Ruby

codesharedot — Thu, 24 Oct 2019 20:55:55 +0000

We aren't talking about the value of a Ruby or a get rich quick talk. No, we are talking about the programming language Ruby.

Getting the bitcoin price is one the simpelest program you can make, while still having a meaning (beyond "Hello World")

How can we do that with Ruby?

Get price with Ruby

The first step is to import some modules, or as ruby calls them gems.

#!/usr/bin/ruby
require 'rubygems'
require 'json'
require 'pp'
require 'open-uri'

Data is retreived from an API. We use an API to download data. In this example we download the bitcoin price.

Data is presetend to the computer in some way. Sometimes its XML Format, sometimes JSON, sometimes something else.

I like the JSON format personally, because it's so simple.

obj = JSON.load(open("https://api.coinmarketcap.com/v1/ticker/bitcoin/"))

Then it returns the JSON data, something like this

[{"id"=>"bitcoin",
  "name"=>"Bitcoin",
  "symbol"=>"BTC",
  "rank"=>"1",
  "price_usd"=>"7511.40312364",
  "price_btc"=>"1.0",
  "24h_volume_usd"=>"16880618621.5",
  "market_cap_usd"=>"135289661862",
  "available_supply"=>"18011237.0",
  "total_supply"=>"18011237.0",
  "max_supply"=>"21000000.0",
  "percent_change_1h"=>"0.05",
  "percent_change_24h"=>"-0.26",
  "percent_change_7d"=>"-7.3",
  "last_updated"=>"1571949454"}]

So we need to get the price (prie_usd). The price has micro cents, mili cents, nano cents and so on. This has no real world meaning, so we round the number after converting it to a floating point number..

val = obj[0]["price_usd"].to_f.round(2)
puts "$ #{val}"

Thats it

Related links

Linux security

codesharedot — Wed, 23 Oct 2019 16:58:11 +0000

There are many softwares to secure your Linux box. You may think you are immune from bad malware, virus, actors. Well, nothing coul be further from the truth. So what can you do? Use some softwares to secure your box:

AppArmor / SELinux

AppArmor / SeLinux tools let you harden your system to the file system level (And beyond). Which apps can access what directories, which app can access the internet and so on.

ClamAV

ClamAV AntiVirus is a free, cross-platform and open-source antivirus software toolkit able to detect many types of malicious software, including viruses.

Firejail

A tool to sandbox your apps. This is more "lightweight" than AppArmor. By runnning in a sandbox, the app can't do bad things outside of what it's supposed to do. Especially useful for web browsers.

Firewalls

UFW

The UFW firewall can block access based on port. If you want to block certain ports (like SSH), you can with UFW. It doesn't allow per-application blocking, only port based blocking.

OpenSnitch

Just an application firewall. If an app tries to access the internet, you'll get a popup asking if it's ok to access the internet

So what do you use? :)

Cat facts with Python and API

codesharedot — Mon, 21 Oct 2019 21:19:55 +0000

Did you know you can get cat facts with Python?

There's a API for cat facts. Yes, really :)

An API lets you get data, it's a "data provider". They are used in almost every web app. This lets you practice with APIs and Python.

It has two end points

URL	what
/facts	Retrieve and query facts
/users*	Get user data

If you open the url https://cat-fact.herokuapp.com/facts you get all the facts in JSON data. An id would give only a single object.

So how to use that in Python?

This little program with requests will do it:

#!/usr/bin/python3
#_*_coding: utf-8_*_
import time
import json
import requests

data = requests.get('https://cat- fact.herokuapp.com/facts/58e0086f0aac31001185ed02')
print(data.json())

Get cat fact

What if you want only one fact?

You can add the id like this:

data = requests.get('https://cat-fact.herokuapp.com/facts/58e0086f0aac31001185ed02')

Then use the text attribute (see inside json object) to get the fact

#!/usr/bin/python3
#_*_coding: utf-8_*_
import time
import json
import requests

data = requests.get('https://cat- 
fact.herokuapp.com/facts/58e0086f0aac31001185ed02')
print(data.json()['text'])

This is how you can interact with the API. Try it out on your own :)

Resources:

Gnome memory monitor extension

codesharedot — Sun, 13 Oct 2019 18:42:54 +0000

You can use Python to create a gnome extension that shows memory use. (Gnome is quite a memory eater).

See that little memory icon with the percentage use? That's what we'll build.

If you have the memory problem with gnome, the lazy fix for this is not to tweak gnome, but to add a more ram memory.

To create gnome extensions in Python, you can use argos. An extension that lets you use Python to create your extension

So first install the argos extension and enable it in gnome-tweak-tool. This extension is in the default ubuntu repo.

The extension can be refreshed, by setting the filename

ram.3s+.py

would referesh every 3 seconds.

ram.6s+.py

would refresh every 6 seconds.

Enter the matrix

Now we type a few lines of Python. The module psutil can give you the current memory use.

#!/usr/bin/python
import os
import psutil

print( str(psutil.virtual_memory()[2]) + "% | iconName=gnome-dev- memory")
print("---")
print("Use: " + str(psutil.virtual_memory()[2]) + "%")
print("---")

Save it in ~/.config/argos

Make sure to

chmod +x your_script.py

Then it will show the memory right in your top bar! :D

Resources:

Bitcoin price ticker in Gnome desktop

codesharedot — Sun, 13 Oct 2019 17:16:13 +0000

Linux is very extensible. You can change almost anything in the system. Are you using the gnome desktop and interested in crypto?

Why Gnome? Gnome is the default desktop on Ubuntu, Debian, OpenSUSE and others.

You can create a gnome extension with argos, using Python. You can create a price ticket for bitcoin. But with a price ticker, it needs to update automatically.

How do you do that?

You can name the file like this:

NAME.POSITION.TIME.EXTENSION

For instance

hello.1r.60s.py

Argos will rerun the plugin every 60 seconds.

Get price

To get the price, you can use the requests module and parse JSON data. There are many APIs available for the bitcoin price like kraken, bitstamp and others. We'll use coinmarketcap

#!/usr/bin/env python

import re
from gi.repository import Gio
from datetime import datetime

import time
import json
import requests

def coin():
    data = requests.get('https://api.coinmarketcap.com/v1/ticker/bitcoin/')
    price = data.json()[0]['price_usd']
    btc_price = float(("{0:.2f}").format(float(price))) 
    return btc_price

usd = float(coin())
lastupdate = datetime.now().strftime('%H:%M:%S')

#print("Bitcoin $" + str(usd) + " (" + str(lastupdate) + ") | n 
#iconName=invest-applet")
print("Bitcoin $" + str(usd) + " | iconName=invest-applet")
print("---")
#print("Kraken: $" + str(usd) + " | iconName=gedit bash=gedit  terminal=false")
print("---")

Now save it as bitcoin.1r.60s.py and it will update the price every 60 seconds. There's a lastupdate variable in the code which you can use, or fork it to create your own clock :P

Resources:

Gnome plugin with Python

codesharedot — Fri, 11 Oct 2019 21:11:17 +0000

You can create Gnome 3.x plugins straight from Python. Of course, you should know Python programming. It's not that hard to do. Great! how do you create a plugin?

Do you use/like Gnome desktop? It's the default desktop on many Linux distros like Ubuntu, Debian, OpenSuse and others.

It's this one:

The setup

It takes some setup before you can run Python script on the gnome desktop. I've tested this on then newest gnome desktop, it may not work for classic gnome desktop (mate).

Setup the argos plugin and enable it using gnome tweak tool.

Click extensions and enable argos. If you don't have tweak tool, run this command

sudo apt install gnome-tweak-tool

Create the gnome plugin

Then open a terminal (Ctrl+Alt+T) and type this

cd ~/.config/argos
nano launcher.py

or any other editor.
Paste the Python code below.

#!/usr/bin/env python

import re
from gi.repository import Gio

print("Python | iconName=starred") 
print("---")
print("Gedit | iconName=gedit bash=gedit terminal=false")
print("Nautilus | iconName=system-file-manager bash=nautilus terminal=false")
print("---")

Save and close. Then type

chmod +x launcher.py

You should now see the Python script output in your tool bar. The plugin argos will scan the directory ~/.config/argos constantly for changes.
Any file you place in there is a plugin.

Related links

Custom dashboard with Flask

codesharedot — Wed, 02 Oct 2019 14:16:54 +0000

In the previous article you learned how to setup a Flask dashboard. That's great and all, but how do you get your own data in there?

I'll show you how to change the dashboard data, so that you can use the dashboard as user interface for your Python app.

the template

Flask has app logic and templates. Templates are html files with the jinja template langue. Templates are stored in the directory /templates.

The top template is stored in /templates/includes/top-stats.html

Change into this:

    <div class="col">
        <h5 class="card-title text-uppercase text-muted mb-0">CPU</h5>
             <span id="stats_traffic" class="h2 font-weight-bold mb-0">{{ cpu }}</span>
    </div>

where {{ and }} is used to show the variable output
(see template language tutorial).

the view

Then open views.py
Scroll down to where it says:

    # App main route + generic routing                                                                     
    @app.route('/', defaults={'path': 'index.html'})
    @app.route('/<path>')
    def index(path):

Then change the lines:

    return render_template('layouts/default.html',
                                content=render_template( 'pages/'+path ) )

Into

    return render_template('layouts/default.html',
                                content=render_template( 'pages/'+path, cpu=99) )

Now restart your local webserver. Open the index url and you'll see your variable in the dashboard:

That's it. The principle works for all templates and pages. You can pass any data, from database, url request or more.

Related links:

Flask dashboard with Python

codesharedot — Tue, 01 Oct 2019 13:19:41 +0000

You can create beautiful web apps with Python. For instance, using Flask dashboards. The module Flask is to make web apps with Python.

But sometimes the installation script on the project page just doesn't work, as it was the case for "flask-argon-dashboard" on my machine.

This is how to fix it for flask-argon-dashboard on Ubuntu Linux.

Setup

Run these commands in the terminal (Ubuntu/Debian):

sudo apt install python3-virtualenv
sudo apt install git

Clone the repo

$ git clone https://github.com/app-generator/flask-argon-dashboard.git
$ cd flask-argon-dashboard

Initialize and activate a virtualenv:

$ virtualenv -p python3 env
$ source env/bin/activate

Install the dependencies:

$ pip install -r requirements.txt
$ pip install flask_login

Create the database, using Flask shell

$ flask shell
$ >>> from app import db
$ >>> db.create_all()

Start server

Run the development server:

$ flask run

See the running app by visiting http://localhost:5000 in your browser

And there you go! Once opened you can see the dashboard.

Happy coding!

Related links: