DEV Community: Enes Karataş

Custom filter options in Ag Grid - Angular

Enes Karataş — Mon, 10 Apr 2023 07:41:52 +0000

Creating custom filter options Ag Grid

Attention

This article signifies custom filtering for each one of filter options in Ag grid. Before starting if you have no idea about Ag grid you can click here and move to the official web site.

Ag grid includes default and robust filtering options already. So you can filter each column separately using one of the options. However sometimes you may not want to filter the data as default options. Or the another circumstance might be like that the data you have doesn't match the filtering options.

As you know the currency formats might be change according to countries or regions. Some of them use comma and the others use point as separator in different digits.

Besides the situation above I just have encountered another problem nowadays. The data includes string values instead integer or float and currency format like #,###.##. In this situation neither text filter option nor number filter option is proper alone. Sounds like weird doesn't it ? So that I just wanted to share my this story.

The data in the picture above has two columns and the first column includes currency format. To filter the data like float number without comma I've modified filter options for each number filter option like following.



public columnDefs: ColDef[] = [
    {
      field: 'sale',
      headerName: 'Sale ($)',
      filter: 'agNumberColumnFilter',
      filterParams: {
        filterOptions: [
          {
            displayKey: 'equals',
            displayName: 'Equals',
            predicate: ([filterValue]: any, cellValue: string) => {
              var valueCase: any = '';
              if (cellValue.indexOf(',') != 0) {
                valueCase = cellValue.replace(/,/g, '');
              }
              return (
                cellValue == null ||
                parseInt(valueCase) == parseInt(filterValue)
              );
            },
          },
          {
            displayKey: 'notEqual',
            displayName: 'Not equal',
            predicate: ([filterValue]: any, cellValue: string) => {
              var valueCase: any = '';
              if (cellValue.indexOf(',') != 0) {
                valueCase = cellValue.replace(/,/g, '');
              }
              cellValue == null || parseInt(valueCase) != parseInt(filterValue);
            },
          },
          {
            displayKey: 'greaterThan',
            displayName: 'Greater than',
            predicate: ([filterValue]: any, cellValue: string) => {
              var valueCase: any = '';
              if (cellValue.indexOf(',') != 0) {
                valueCase = cellValue.replace(/,/g, '');
              }
              return (
                cellValue == null || parseInt(valueCase) > parseInt(filterValue)
              );
            },
          },
          {
            displayKey: 'lessThans',
            displayName: 'Less than',
            predicate: ([filterValue]: any, cellValue: string) => {
              var valueCase: any = '';
              if (cellValue.indexOf(',') != 0) {
                valueCase = cellValue.replace(/,/g, '');
              }
              return (
                cellValue == null || parseInt(valueCase) < parseInt(filterValue)
              );
            },
          },
          {
            displayKey: 'greaterThanOrEqual',
            displayName: 'Greater than or equals',
            predicate: ([filterValue]: any, cellValue: string) => {
              var valueCase: any = '';
              if (cellValue.indexOf(',') != 0) {
                valueCase = cellValue.replace(/,/g, '');
              }
              return (
                cellValue == null ||
                parseInt(valueCase) == parseInt(filterValue)
              );
            },
          },
          {
            displayKey: 'lessThansOrEqual',
            displayName: 'Less than or equals',
            predicate: ([filterValue]: any, cellValue: string) => {
              var valueCase: any = '';
              if (cellValue.indexOf(',') != 0) {
                valueCase = cellValue.replace(/,/g, '');
              }
              return (
                cellValue == null || parseInt(valueCase) < parseInt(filterValue)
              );
            },
          },
          {
            displayKey: 'inRange',
            displayName: 'In range',
            predicate: ([fv1, fv2]: any, cellValue: any) => {
              var valueCase: any = '';
              if (cellValue.indexOf(',') != 0) {
                valueCase = cellValue.replace(/,/g, '');
              }
              return (
                cellValue == null ||
                (parseInt(fv1) < parseInt(valueCase) &&
                  parseInt(fv2) > parseInt(valueCase))
              );
            },
            numberOfInputs: 2,
          },
        ],
      },
    },
    {
      field: 'product',
      headerName: 'Product',
      filter: 'agTextColumnFilter',
    },
  ];

The other definitions like rowdata, defaultColDef, etc. as usual. I would like to point out that for each option the data was saved from comma. You can also add more custom filter using this way. If you use export options you are able to edit data using filterOptions like this which doesn't affect the export.

Note: You can find the entire project here .

Thank you for reading.

Simple XSS Prevention Method in Javascript

Enes Karataş — Sat, 07 Jan 2023 09:46:35 +0000

About the content

📌 This post includes a simple XSS prevention method on the javascript(express) server side.

Basics

XSS(Cross-site scripting) is most common vulnerability on the web applications. Most of the web applications have field like user input, login form, search etc. so the attackers can put the malicious javascript code in these input fields. Many information like user sessions can be stolen by proper input. There are some various of XSS like Reflected XSS, DOM XSS and Stored XSS,

Anyways I am not going into deep detail about XSS so I guess you have sufficient knowledge so far.

Code

Now it is time to show how to prevent on express API. Firstly the basic project should be created. The next we are going to create a vulnerable API structure using Nodejs(Express.js) and get the input from static login form file.

You can follow the instructions below to create API easily.
Open the terminal and run the followings.

start the project

npm init -y

create a folder that will contain static files like html.

mkdir static
cd static
touch login.html

Go back to root directory and create a server file.

touch server.js

Install required packages.

npm install express body-parser

Time to configure and run out the API server in server.js.

const express = require('express');
const bodyParser = require('body-parser');
const path = require('path');
const app = express();

app.use(bodyParser.urlencoded({ extended: false }));

Get the login page while server is run

app.get('*', (req, res) => {
    res.sendFile(path.join(__dirname, '/static/login.html')); 
});

Create post request to get user information and run the server.

app.post('/login', (req, res) => {
    res.status(200).send(
        "<div>" + req.body.username + " logged in!</div>"
    );
});

const PORT = '3000';

app.listen(PORT, () => {
    console.log(`listen on port: ${PORT}`);
});

Create the login form in login.html.

<!DOCTYPE html>
<html>
  <head>
    <title>Example Login Form</title>
  </head>
  <body>
    <form action="/login" method="post">
      <!-- user input-->
      Username:<br />
      <input
        type="text"
        name="username"
        placeholder="Username"
        required
      /><br /><br />
      Password:<br />
      <input
        type="password"
        name="password"
        placeholder="Password"
        required
      /><br /><br />
      <!-- submit button -->
      <input type="submit" value="login" />
    </form>
  </body>
</html>

Run the server on terminal.

node server

👉 Checkout the localhost:3000 on the browser and get to the login page like following.

If you get the same everything is well so far ! 👍

Enter username and password without any payload, server also returns username on the success page.

Go back to login page and enter one of XSS payloads from following as username and also you can find more yourself.

You are going to get an alert notification like this so the main thing is how to prevent it.

Prevention Methods

Direct use of res.send() or res.write() might cause some problem like above.

Alternatively, use res.render() instead however they are not the same methods. Sometimes you might need to use res.send() or res.write() methods therefore need to sanitize method.

Let's write a sanitizer over String class! Move on the bottom of server.js and define the function below.

function onChangeString() {
    String.prototype.escape = function() {
        var tagsToReplace = {
            '&': '&amp;',
            '<': '&lt;',
            '>': '&gt;',
            '"': '&quot',    
        };
        return this.replace(/[&<>"]/g, function(tag) {
            return tagsToReplace[tag] || tag;
        });
    };
}

Call the function like onChangeString() after package definitions and rewrite the post method using custom escape method that defined over String class.

app.post('/login', (req, res) => {
    res.status(200).send(
        "<div>" + (req.body.username).escape() + " logged in!</div>" // prevent xss using String class based escape method 
    );
});

Check again on the browser and so you will see the payload as a string on the response.

Use of escape method detects some special entities from the string type user input. The main idea behind sanitization is escaping the some special characters like '<', '>', '"' or many of them.

To check the entire project please visit my Github account.

Thank you for reading.
Have a nice day!

filter() method in JavaScript

Enes Karataş — Wed, 28 Sep 2022 13:23:44 +0000

What is filter() used for ?

Sometimes you might want to do some changes on array so, to do that you need to use array methods in javascript. The filter() method is one of them. This method is used for filtering an array. It copies the given array and creates a new array using filtered elements from actual array. Suppose you have an array and only specific elements should be returned from the array. Let's see how to do that using filter().

How to use filter() method ?

Before use the method we are going to take a look at its syntax.

The syntax is

filter((element) => { /* … / } )
or
filter(function(element) { / … */ })

Alrigt let's do the first example. Suppose you have an array like [1, 2, 3, 4, 5, 6, 7, 8, 9] and want to get the only odd numbers.

   var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
   const oddArr = arr.filter(element => element%2 == 0);

If you print out oddArr on console or page you are going to see a new array contains only odd numbers.

Attention !

filter() method doesn't change the original array.
filter() method creates a new array to fill with the selected elements by given condition.

We can also use filter() method on arrays includes string type element.

var format = /[ `!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?~]/;

const words = ['spray', '!limit#3', 'racing', '^b4n4n4*', '&basketball&', 'my$bird', 'animals', 'it_is_good_to_us', 'specialCars', 'sweet fruites']

const formattedArray = words.filter(w => w.length >= 6 && format.test(w) == false);

console.log(formattedArray) // [ 'racing', 'animals', 'specialCars' ]

The following example will create an array that doesn't include undefined items. To do that we are going to pass a function as parameter and see how to use without arrow function.

const arr = [
  { id: 15 },
  { id: -1 },
  { id: 0 },
  { id: 3 },
  { id: 12.2 },
  {},
  { id: null },
  { id: NaN },
  { id: 'undefined' },
];

function catchUndefined(element) {
    if (element.id !== 0 && Number.isFinite(element.id) && element.id > 0) {
        return true;
    } else {
        return false;   
    }
}
const filteredArrById = arr.filter(catchUndefined);
console.log(filteredArrById);

Output

[ { id: 15 }, { id: 3 }, { id: 12.2 } ]

Another example will be around the numbers again. In this time we are going to find prime numbers from given array.

function isPrime(number) {
    if (number > 1) {
        for (let i = 2; i < number; i++) {
            if (number % i != 0) {
                continue;
            } else {
                return false;
            }
        }
    } else {
        return false;
    }
    return true;
}

const numbers = [3, 8, 2, 5, 4, 6, 11, 9, 7, 1, 24, 21, 17, -5, -7, -9]
const primeNumbers = numbers.filter(isPrime);
console.log(primeNumbers); // [ 3, 2, 5, 11, 7, 17 ]

After run the code above you are going to see the prime number list. Anyways, let's make an another instance using string type list.

const cars = ["BWM", "Audi", "Mercedes", "Volvo", "Subaru", "Volkswagen", "Hyundai", "Rolce Royce", "Bentley", "Nissan"];

query = "r"; // something else you want
const filteredByQuery = cars.filter(element => element.toLowerCase().trim().includes(query.toLowerCase().trim()));
console.log(filteredByQuery);

In the code above finds the proper elements according to given query. It searchs in the whole list and return item includes the query string.

So far so good !
You can make various examples to learn more and also look at these array methods map() and forEach().

Thank you so much for reading.

Custom Error Class in Angular 12+

Enes Karataş — Sat, 13 Aug 2022 10:51:03 +0000

How to create custom error class in Angular ?

Sometimes you don't want to use the default error class already exists so, in these times you need to write your own error class. To do that you should follow several steps and we are going to investigate all step by step.

In this essay I have just built my own custom error class so that you don't have to use the same logic. You can modify your class using your OOP knowledges and logic. Anyways let's code it !

Angular will be used in this case so that If you don't have yet you should have it before. To get this please visit this site angular.io.

Creating new angular project

First create a new angular project on the terminal/powershell then open the project folder on the editor. My current editor is Visual Studio Code.

Note that you should allow routing while creating the application.

ng new 'project name'

cd 'project folder'

ng serve

If you use vscode you can run the project using new terminal on the navbar.

Alright now it is time to implement on the project. I am not going to implement the changes on the app component directly, instead I will create another component to do that.

cd src/app
mkdir pages
cd pages
ng g c customError

To see the page of component you should add the route path to app-routing.module.ts.

   const routes: Routes = [
     { path: 'customError', component: CustomErrorComponent }
   ];

Once the application is run you are going to see that the page works! So far so good!

To create a custom class and use in error component I am going to use angular model type. Under the app folder create a new folder named as models. Open new terminal in the models and look at the followings.

cd models
ng g class CustomError --type=model

CustomError class has been created in the models folder. We will implement the all changes on this class.

Now you have an empty file named like custom-error.model.ts so, it is time to define a class like following code.

custom-error.model.ts

export class CustomError extends Error {
    constructor(
        msg: string,
        private statusCode?: number, // optional variable
    ) {
        super(msg);
        Object.setPrototypeOf(this, CustomError.prototype);
    }
    alertError(): string{
        return this.statusCode ? `Custom Error: Status => ${this.statusCode}, Message => ${this.message}` : `Custom Error: Message => ${this.message}`;
    }
}

In the code above we have just defined the class we want and this class extends to Error class defined by default in typescript. As you could see there is an another optional variable named like statusCode under the msg. To give an error code to the class it will be used.

Let's go to the component ! Model is called on the top of the custom-error.component.ts like the following and I've just written a function callCustomErrorModel to call our class that I have created.

import { CustomError } from 'src/app/models/custom-error.model';

  errorMessage: any;
  constructor() { 
    this.callCustomErrorModel();
  }

  callCustomErrorModel(){
    let newError = new CustomError('this is new error instance', 101);
    if(newError instanceof CustomError) {
      this.errorMessage = newError.alertError();
    }
  }

You are going to see the message on the page while you go to the url localhost:4200/customError.

Definitely you can get the all codes and improve them so access the codes here.

Remove duplicate items in list, Python.

Enes Karataş — Sun, 05 Jun 2022 12:43:27 +0000

How to remove duplicate list items in python ?

Introduction

There are some options and features to remove duplicate items in a list. We are going to investigate some of them without any module (pandas, numpy etc.) in this essay.
Let's code !

Step by Step: Remove duplicate items from list

To be able to do that firstly we are going to use one of most common way, that is iteration by for loop. Assume we have a list including duplicate items like this list = [1, 2, 2, 3, 4, 5, 5, ...]. So we can use an iterator in a loop to remove duplicate items from list.

   def remove_duplicate(dup_list) -> None:
       result_list = list()
       [result_list.append(i) for i in dup_list if i not in result_list]
       print(f"Result -> {result_list}")

When the code above is run in the main method the output will be like following:

   if __name__ == "__main__":
      remove_duplicate(dup_list = [1, 2, 2, 3, 3, 4, 5])

   Result List -> [1, 2, 3, 4, 5]

As you see above code we have used the optimized way to create list. Anyways let's try the other options that we can. One of the others is removing item from the original list by count() method. Think about that like the reverse of before instance. We will not create a new list, just delete duplicate items.

   def remove_duplicate(dup_list) -> None:
       for i in dup_list[:]:
           if dup_list.count(i) > 1:
               dup_list.remove(i)
       print(f"Result List => {dup_list}")

  if __name__ == "__main__":
     remove_duplicate(dup_list = [1, 2, 2, 3, 3, 4, 5])

   Output:
   Result List -> [1, 2, 3, 4, 5]

Note that we use the list like dup_list[:] in for loop because we want to remove items without any skipping. Unless you use the whole copy of the list as we do the iterator will skip the item after remove.

So far so good ! Now we will use dictionary to remove items. To do that we need fromkeys() method however, If you don't know what that module is you can search on the net. There are two parameters for this module and those are sequence and value. Value parameter is optional so it depends on what you need.

Syntax:

dict.fromkeys(sequence, value(optional))

   result = list(dict.fromkeys(dup_list))
   print(f"Result List => {result}")

Check the output out.

   Output:
   Result List -> [1, 2, 3, 4, 5]

There is one more way to do that similar to the method above but this is slower than the fromkeys method.

   convert_to_set = list(set(dup_list))
   convert_to_set.sort(key=dup_list.index)
   print(f"Result List => {convert_to_set}")

   Output:
   Result List -> [1, 2, 3, 4, 5]

That's all in this tutorial. I think the fastest way is fromkeys() method. Compare them each other and share your comments.

Thank you for reading. :)

"grep" Command In Linux/Unix

Enes Karataş — Tue, 30 Nov 2021 16:42:11 +0000

Getting Started With "grep"

➔ This tutorial is written to inform about grep command and its usage in Linux/UNIX system. In the next tutorials I am planning to share all the commands that I have used before.

Anyways, let's look at how to use the command.

How to use grep command ?

The grep command is one of the most useful linux command for linux users. It used to search given string or world in a file or process. It takes given string or word and returns including correct match.

The command is also stands for "Globally search for a Regular Expression and Print it out". There are some useful parameters that grep takes. We are going to use each other with grep in examples.

Examples

Firstly I've created test.txt to use as file. The content of this file like following.

   linuxuser@ubuntu:~/Desktop$ cat test.txt

Username: User
Password: UserPassword
Name: John
Lastname: Doe
Adress: FakeStreet FakeCountry no: 24 postal: 00000

To be able to find something in the file the simple usage of command can be used without parameter.

   linuxuser@ubuntu:~/Desktop$ grep Street test.txt

Output will be like following.

   Adress: FakeStreet FakeCountry no: 24 postal: 00000

In the terminal command above we searched for the word Street and get the line including Street.

We can also use -i parameter to search as case-insensitive.

   linuxuser@ubuntu:~/Desktop$ grep -i stReEt test.txt

Output will be the same with first example.

   Adress: FakeStreet FakeCountry no: 24 postal: 00000

‼️ Note that the grep function returns us a line where the given string is part of the word such as 'Street' and 'FakeStreet' so that if you want to search the line of the whole word matches you should use -w parameter.

   linuxuser@ubuntu:~/Desktop$ grep -w Username test.txt

In the output below we could see given string in terminal command.

   Username: User

To find line number with search result you can use -n parameter.

   linuxuser@ubuntu:~/Desktop$ grep -n Address test.txt

   5:Address: FakeStreet FakeCountry no: 24 postal: 00000

As you can see in the output there is line number like "5".

What if you want to know how many match line after running command ?
Sure there is a parameter to do that. -c parameter is used to count matches and also stands for count.

   linuxuser@ubuntu:~/Desktop$ grep -c "User" test.txt

We got output "2" and if you go to content of test.txt you are going to see 2 line matches probably.

The -v option returns the all lines that don't contain a matches corresponding to the given string.

   linuxuser@ubuntu:~/Desktop$ grep -v User test.txt

   Name: John
   Lastname: Doe
   Address: FakeStreet FakeCountry no: 24 postal: 00000

There are some options like -B and -A that mean "BEFORE" and "AFTER" or at least you can think about it like that to make permanent in your mind 😉. So those options are used to get to the previous or next lines of matching lines.

   linuxuser@ubuntu:~/Desktop$ grep -A 1 User test.txt

   Username: User
   Password: UserPassword
   Name: John

In the output above there is one more line apart of the User matching lines that is Name: John. If you put 2 instead of 1 in the command above you probably are going to get two more lines. For instance:

   Username: User
   Password: UserPassword
   Name: John
   Lastname: Doe

Let's try the other one with the same logic. This time we are going to use -B parameter.

   linuxuser@ubuntu:~/Desktop$ grep -B 2 User test.txt

When we run out the command above we see the output like below. There are two more line before the matching lines as you can see in the output below.

   Name: John
   Lastname: Doe
   Address: FakeStreet FakeCountry no: 24 postal: 00000

All the examples have been done using file so far. Let's use grep on different ways. For instance sometimes you use ping command in the both linux and windows. So you can also use grep with ping command. Let me show an instance here.

   ping 8.8.8.8 | grep -i ttl

You probably get the same result so each of the successful response lines has ttl value. We need to search something that doesn't exist on each line. Suppose you want to check internet connection via ping.

   linuxuser@ubuntu:~$ping 8.8.8.8 | grep -i "Request timed out"

   linuxuser@ubuntu:~$ ping 8.8.8.8 | grep -i 'request timed out\ | host unreachable'

The both request timed out and host unreachable will be searched on this way. You can increase the samples yourself.

Let's do some searching in the files under the directories.
To make searching under directory you need to use grep as recursively. To be able to do that -r or -R options can be used. Let's make a searching for the default router IPs using 192.168.1.5 address.

   linuxuser@ubuntu:~$ sudo grep -R "192.168.1.5" /etc/

   /etc/ppp/options:# ms-wins 192.168.1.50
   /etc/ppp/options:# ms-wins 192.168.1.51

The other example would be about your system information. Under the /proc directory there is a file named cpuinfo that contains information about your system. It is time to manipulate this file !

   linuxuser@ubuntu:~$ ls /proc

The first we've listed the files and directories. Now we are going to write the content of cpuinfo file.

   linuxuser@ubuntu:~$ cat /proc/cpuinfo

   processor    : 0
   vendor_id    : GenuineIntel
   cpu family   : 6
   model    : 140
   model name   : 11th Gen Intel(R) Core(TM) i5-1135G7 @ 2.40GHz
   stepping : 1
   microcode    : 0x86
   .
   .
   .
   .

This is mine and you will get the result like this. Alright let's search something in this file using grep.

   linuxuser@ubuntu:~$ cat /proc/cpuinfo | grep -i cpu

   cpu family   : 6
   cpu MHz  : 2419.199
   cpu cores    : 1
   cpuid level  : 27

In the example above we've searched "cpu" word in cpuinfo file. So the same process also can be done using the command below.

   linuxuser@ubuntu:~$ grep -r cpu /proc/cpuinfo

Let us take a look at what else we can do. We are going to create a bash script file and write something in this file. For instance the informations in the cpuinfo file can be written to another .txt file.

Creating a bash script file named file_script.sh.

   touch file_script.sh

Editing on nano editor. That is my choice, you can also use another one else.

   nano file_script.sh

   #!/bin/bash

   function write_to_file()
   {
        read -p "Enter file name(ex: filename.txt): " FILENAME
        SYSTEMINFO=$(cat /proc/cpuinfo | grep -i name)
        printf "%s\n" "$SYSTEMINFO" >> $FILENAME
   }

   write_to_file

The content of script file is above and it can be improved more. Once you run out the code file you will need enter the file name where the searching is stored. When you see the inside of the file that you named on script you are going to see the searching result. If you don't want to show the file name while you write then you can use -s option before -p.

It is time to the last example now. Consider you have a file containing public domain list and you want to search for domains only containing .com on this file and extract to the other one.

Let's write this script !


function extract_domains()
{
        TARGETFILE='extracted.txt'
        FILENAME='domains.txt'
        _DOMAINS=$(cat $FILENAME | grep -i .com)

        printf "%s\n" "$_DOMAINS" >> $TARGETFILE

        FILE=$TARGETFILE
        if [ -f "$FILE" ]; then
                echo "$FILE exists. All the domains end with '.com' are extracted !"
        fi

}
extract_domains

   extracted.txt exists. All the domains end with '.com' are extracted !

Let us explain the code above. There is a file named domains.txt on your current directory. So the file stores public domain list and we've searched all the domains end with .com on the domains.txt. All searched domains are written to extracted.txt and checked if the file exists. If so then the output returned otherwise you would get the output like "file doesn't exists !".

Thank you so much for reading.
Have a good day !

Requests module in Python: 📭 How to use requests in Python ?

Enes Karataş — Mon, 01 Nov 2021 09:12:28 +0000

Getting Started with Requests

👉 Every web developer knows HTTP methods and almost their usage. So, how we can handle those methods using python ? Of course one of the efficient way to use those methods is requests module.

📌 The requests module is quite common used module in python. In this essay we are going to investigate what requests is and how to use with most common HTTP methods.

To begin using the requests module it should be installed before. To do this, run the following code:

pip install requests

After installing the module it is time to code ! Make sure the module is imported before code.

import requests

That's it! Now we are ready to use requests. 🛠
Let's take a look at what we are able to do using requests.

The GET Request

One of the most two common HTTP methods GET is used for reach out the data from specific resource. Python provides us get() method that takes data resource as argument in requests module.

To be able to do that we will make GET request to http://api.open-notify.org/. This API page has been created as an open source project for the purpose of information so, you can find something on this page about the ISS and astronauts in the space right now.
Alright, let's code !

   def req():
       response = requests.get("http://api.open-notify.org/")
       print(response)

Running out the req() function in the main method we will have our the first request in this manner.

   def __name__ == "__main__":
       req()

After run the code above you probably are going to get the following response

Output:
<Response [200]>

As you can see in the output the get() method returned us response by status code 200. That means the request was successful to resource.

📌 Note that there will more info associated with HTTP Status Codes later.

Alright we have a response and its class and we know that all the content is stored in response variable so that we need to access them now. To do this there are some way that we can use. So why don't we try some of them ⁉️

Before getting content of response we are going to check status whether successful or not. It might be useful to make decision on the code.

   def status():
       if response.status_code == 200:
           return True
       return False

If the output is True then the request was successful.
‼️ However, note that you can not check out the all status codes one by one. Instead of that you can use raise_for_status() function that will do necessary process for you.

   def status():
       try:
           response = requests.get("http://api.open-notify.org/asdasd")
           response.raise_for_status()
       except Exception as e:
           print(f'Error occurred: {e}')

If an exception occurs you would probably get an HTTPError in the output.

So, after checking out the response we can focus on the content of response variable. The content of response variable that you got from the GET method may contain valuable information called as payload. To see the content we are going to use content by response variable.

   def content(url="http://api.open-notify.org/astros.json"):
       try:
           response = requests.get(url)
           content = response.content
           print(content)
       except Exception as e:
           print(f'Error occurred: {e}')

Output:
b'{"message": "success", "number": 10, "people": [{"craft": "ISS", "name": "Mark Vande Hei"}, {"craft": "ISS", "name": "Oleg Novitskiy"}, {"craft": "ISS", "name": "Pyotr Dubrov"}, {"craft": "ISS", "name": "Thomas Pesquet"}, {"craft": "ISS", "name": "Megan McArthur"}, {"craft": "ISS", "name": "Shane Kimbrough"}, {"craft": "ISS", "name": "Akihiko Hoshide"}, {"craft": "ISS", "name": "Anton Shkaplerov"}, {"craft": "ISS", "name": "Klim Shipenko"}, {"craft": "ISS", "name": "Yulia Pereslid"}]}'

This function returns us raw byte value of response payload like output above. The output inform us about astronauts in the space right now.

We usually want to get in different form like json, string etc. To convert the response into string just enough using the text function.

   def convert_string(url="http://api.open-notify.org/astros.json"):

       try:
           response = requests.get(url)
           string_content = response.text
           print(f"The content of response => {string_content}")
       except Exception as e:
           print(f'Error occurred: {e}')

The output will be into string form like this :

The content of response => {"message": "success", "number"...

If you take a look at the content of response you are going to see it is like JSON. However, how can we access as JSON format? There is an easy way to get content by JSON so requests module provide us its own json() function to convert content of response to JSON format.

   def convert_json(url="http://api.open-notify.org/astros.json"):

       try:
           response = requests.get(url)
           json_content = response.json()
           print(f"The content of response => {json_content}")
           print(type(json_content))

       except Exception as e:
           print(f'Error occurred: {e}')

Almost the same output but not in the text form in this time. If you check out the type of json_content variable in the code above you will get .

You can also use pprint module instead of print function while you write the JSON content. You would get the output like following.

The content of response => {'message': 'success',
 'number': 10,
 'people': [{'craft': 'ISS', 'name': 'Mark Vande Hei'},
            {'craft': 'ISS', 'name': 'Oleg Novitskiy'},
            {'craft': 'ISS', 'name': 'Pyotr Dubrov'},
            {'craft': 'ISS', 'name': 'Thomas Pesquet'},
            {'craft': 'ISS', 'name': 'Megan McArthur'},
            {'craft': 'ISS', 'name': 'Shane Kimbrough'},
            {'craft': 'ISS', 'name': 'Akihiko Hoshide'},
            {'craft': 'ISS', 'name': 'Anton Shkaplerov'},
            {'craft': 'ISS', 'name': 'Klim Shipenko'},
            {'craft': 'ISS', 'name': 'Yulia Pereslid'}]}

Working with Headers 🕵🏼

To get more information about the response that you got there is need to access headers of the response. To view those headers python requests module provides us headers function. Take a look at this how to implement headers on response of get request.

   def get_headers(url="http://api.open-notify.org/astros.json"):

       try:
           response = requests.get(url)
           headers = response.headers
           print("Headers: ", end="\n\n")
           pprint(dict(headers))

       except Exception as e:
           print(f'Error occurred: {e}')

Output:
Headers:

{'Connection': 'keep-alive',
 'Content-Length': '505',
 'Content-Type': 'application/json',
 'Date': 'Mon, 18 Oct 2021 08:39:23 GMT',
 'Server': 'nginx/1.10.3',
 'access-control-allow-origin': '*'}

A lot of details we can get by the headers as you can see in the output above. To access one of them we can also use python dictionary properties. For instance in the code above we can check the server or whatever you want using this headers.get('Server'). You probably are going to obtain that response nginx/1.10.3.

Query Parameters

Sometimes we may want to filter in the response.Query parameters can be used to customize the response of GET method. To do this the parameters that we have determined should be passed to params in get() function.

For instance;

   def query_params(url="http://api.open-notify.org/iss-pass.json"):
       params = {
           "lat":"25",
           "lon":"35"
           }
       try:
           response = requests.get(url, params=params)
           json_content = response.json()
           print(f"Estimate of ISS location according to parameter => ", end="")
           pprint(json_content)
       except Exception as e:
           print(f'Error occurred: {e}')

Output:
Estimate of ISS location according to parameter => {'message': 'success',
 'request': {'altitude': 100,
             'datetime': 1634224449,
             'latitude': 25.0,
             'longitude': 35.0,
             'passes': 5},
 'response': [{'duration': 613, 'risetime': 1634270566},
              {'duration': 590, 'risetime': 1634276384},
              {'duration': 502, 'risetime': 1634300139},
              {'duration': 648, 'risetime': 1634305891},
              {'duration': 193, 'risetime': 1634311894}]}

The code above yields us an estimation about the ISS according to given parameter's data. When you make GET request to this url without query parameter then you would get a response message that it is must.

If you want to get information about current location of ISS then make GET request using this url: http://api.open-notify.org/iss-now.json.

What if we want to approach by OOP to estimate ISS location ⁉️⁉️⁉️

   class EstimateISS:

         def __init__(self, url="http://api.open-notify.org/iss-pass.json"):

            self.lat = int(input("latitude: "))
            self.lon = int(input("longitude: "))
            self.url = url

        def estimate_request(self):

            params = {
                "lat": self.lat,
                "lon": self.lon
                }

            try:
                response = requests.get(self.url, params=params)
                self.json_content = response.json()
                return self.json_content

            except Exception as e:
                return f'Error occurred: {e}'

        def __repr__(self):
            return f"{pprint(self.estimate_request())}"

Have a look at the code above that what it does. When the code is run firstly gets latitude and longitude in init function and moves to other key function, estimate_request(). The both parameters and other processes occur in this function. If no error, it estimation about ISS location according to given values

latitude: 45
longitude: 30


{'message': 'success',
 'request': {'altitude': 100,
             'datetime': 1634908665,
             'latitude': 45.0,
             'longitude': 30.0,
             'passes': 5},
 'response': [{'duration': 600, 'risetime': 1634956714},
              {'duration': 655, 'risetime': 1634962480},
              {'duration': 627, 'risetime': 1634968328},
              {'duration': 635, 'risetime': 1634974172},
              {'duration': 652, 'risetime': 1634979986}]}

Working on POST Method

One of the another most famous method is POST. To be able to use this method we need a body that gets data its inside. The body gets dictionary, a list of tuple, byte or object according to corresponding function parameters. Firstly, we are going to use that site https://httpbin.org/ to post method.

   def post_data(url="https://httpbin.org/post"):
       data = {"key": "value"}
       response = requests.post(url, data=data)
       print(response)

   Response [200]

We got the status code 200 in the response above. So if we need to access response headers is there any header in the response that returned in post method ?
Of course, we can demonstrate the all headers like what we did for get.

   def post_data(url="https://httpbin.org/post"):
       data = {"key": "value"}
       response = requests.post(url, data=data)
       headers = response.headers
       pprint(dict(headers))

{'Access-Control-Allow-Credentials': 'true',
 'Access-Control-Allow-Origin': '*',
 'Connection': 'keep-alive',
 'Content-Length': '479',
 'Content-Type': 'application/json',
 'Date': 'Mon, 25 Oct 2021 11:02:35 GMT',
 'Server': 'gunicorn/19.9.0'}

In the output above we can see the headers for post method we sent. Note that those processes are related to web requests and responses so that we can build up communication by JSON data. To use that in the post method just pass data as json parameter.

   def post_json_data(url="https://httpbin.org/post"):
       data = {"key": "value"}
       response = requests.post(url, json=data)
       headers = response.headers
       content = response.content
       dec = content.decode("utf-8")
       json_cont = json.loads(dec)
       pprint(json_cont)

In the code above we have changed the data by json and run again. Let's look at the data inside of the response content.

{'args': {},
 'data': '{"key": "value"}',
 'files': {},
 'form': {},
 'headers': {'Accept': '*/*',
             'Accept-Encoding': 'gzip, deflate',
             'Content-Length': '16',
             'Content-Type': 'application/json',
             'Host': 'httpbin.org',
             'User-Agent': 'python-requests/2.26.0',
             'X-Amzn-Trace-Id': 'Root=1-6177e4a2-25a616ba208403692f718992'},
 'json': {'key': 'value'},
 'origin': '176.236.37.52',
 'url': 'https://httpbin.org/post'}

Pay attention to those points data and json inside of the response content. When you look at the data and json keys you are going to see a dictionary that we have sent.
So far so good ‼️

Alright, as we said before this is related to web process so, why we don't write a mini web server and make request to that 🤔 ⁉️

Ok then let's do it ‼️

To be able to do that we'll need some modules one of them is flask. Firstly we will use flask to get requests and return responses. I thought it is easy way in python for now. In the another one sharing we are going to use flask with its all details.

First of all we need to import some packages from flask module.

   from flask import Flask, request

Now, we can run out the flask and use its properties.

   app = Flask(__name__)

   @app.route("/test/test_get", methods=["POST", "GET"])
   def get():
       if request.method == "GET":
          return jsonify({"message": "Success!"})
       return

To run out flask app we need to add and run this code in main method below.

   if __name__ == "__main__":
      app.run(debug=True)

After running out the server you will get an output about it is running.

 * Serving Flask app 'test_server' (lazy loading)
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: on
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 735-221-534
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Now, it is time to make request to our test server. Alright we need to move on other python file and write following.

   def test_get():
       try: 
        response = requests.get("http://127.0.0.1:5000/test/test_get")
        if response.status_code == 200:
           print("Success!")
      except Exception as e:
           print(e)

Run the code above in a different python file you are going to get Success! if you don't have an exception. Apart of that if you go to browser by this url you would get that response message: Success!.

Let's do something to make post request to the test server. Go back to the file that have flask and write another function called as post() like following.

   @app.route("/test/test_post", methods=["POST", "GET"])
   def post():
       try:
           post_data = request.json
           if request.method == "POST":
              return post_data
           return
       except Exception as e:
          return e

Now we need a function to be able to send json data to the server via post request. Ok let's do it !

   def test_post():
       header = {"Content-Type":"application/json",}
       url = "http://127.0.0.1:5000/test/test_post"
       post_data = {
               "message": "this message from post request"
           }
       json_data = json.dumps(post_data)
       try:
           response = requests.post(url=url,headers=header, data=json_data)
           return_content = json.loads(response.content)
           if response.status_code == 200:
               print("Success!")
               print("Returned data: ", return_content)

       except Exception as e:
           print(e)

The server gets request that sent from test_post() function and returns the content of request. When we run out the both file the outputs will be like following. Firstly the server return us status code and the function prints out message according to this status code.

127.0.0.1 - - [28/Oct/2021 10:45:47] "POST /test/test_post HTTP/1.1" 200 -

Success!
Returned data:  {'message': 'this message from post request'}

So far so good !
You can also diversify using other HTTP methods like PATCH, PUT, DELETE. We are going to write the last instance using one of them.

This time we got PUT method to use with function. Suppose we have list database holding dictionary data in the test server and we are going to change something on the data using PUT. Let's code it!

   @app.route("/test/test_put", methods=["POST", "PUT"])
   def put():

       _db = [
           {"Id": "1",
            "user": "fake",
            "pass": "fake"}
           ]    
       try:
           put_data = request.json
           if request.method == "PUT":
              for _ in _db:
                  if _["Id"] == put_data["Id"]:
                     _["user"] = put_data["user"]
                     _["pass"] = put_data["pass"]
           print(_db)
           return put_data
       except Exception as e:
           return e

In the code above _db created like database and db updated in try block according to Id using incoming data.

   def test_put():
       header = {"Content-Type":"application/json",}
       url = "http://127.0.0.1:5000/test/test_put"
       put_data = {
               "Id": "1",
               "user": "fakeuser",
               "pass": "fakepass"
           }
       json_data = json.dumps(put_data)
       try:
           response = requests.put(url=url,headers=header, data=json_data)
           return_content = json.loads(response.content)
           if response.status_code == 200:
               print("Success!")
               print("User Updated by: ", return_content["user"])

       except Exception as e:
           print(e)

When we run the code files in order, outputs will be like following.

Success!
User Updated by:  fakeuser

And the server outputs:

[{'Id': '1', 'user': 'fakeuser', 'pass': 'fakepass'}]
127.0.0.1 - - [01/Nov/2021 09:30:45] "PUT /test/test_put HTTP/1.1" 200 -

Server side also prints out the updated _db and status code 200. We are be able to create new record into the database using POST method and delete it again using DELETE method. Let us build up delete function to delete record that already created.

   def test_delete():
       header = {"Content-Type":"application/json",}
       url = "http://127.0.0.1:5000/test/test_delete"
       delete_data = {
               "Id": "1",
               "user": "fakeuser",
               "pass": "fakepass"
           }
       json_data = json.dumps(delete_data)
       try:
           response = requests.delete(url=url,headers=header, data=json_data)
           if response.status_code == 200:
               print("Success!")

       except Exception as e:
           print(e)

Now let's write the server side.

   @app.route("/test/test_delete", methods=["POST", "DELETE"])
   def delete():
       _db = [
           {"Id": "1",
            "user": "fake",
            "pass": "fake"}
           ]    
       try:
           delete_data = request.json
           if request.method == "DELETE":
               for _ in _db:
                   if _["Id"] == delete_data["Id"]:
                       _db.remove(_)
           print(_db)
           return delete_data
       except Exception as e:
           return e

As the last, server prints empty db if status code 200.

[]

Thank you so much for reading the essay. The new one will come soon...
Good day !

Python map() Function: How to use map in python ?

Enes Karataş — Sun, 03 Oct 2021 20:22:43 +0000

Python map() Function : How to work ?

📍 Hello everyone in this tutorial we are going to investigate map() function in python together. Firstly we are going to start with what map() is.
👉 The map() function is used for doing some process with all the items in an iterable(list, tuple etc.) without using a loop. When you need to apply given function to each item in an iterable the map() can be pretty useful. Alright let's go ahead the next step !

Getting started with map() function

Sometimes you might want to apply process to all the items of an iterable. The most common approach to do that is using for loop in python. However we are going to handle this situation without using loop. So, this way is map().

Before using the map() function we don't need to import any module so, to be able to use the map() you need to use just directly in python file that's sufficient.
The syntax of the map() function as the following:

map(function, iterable[...iterable(N)])

Let us begin with the most common example. Suppose you have a list and you want to transform square the each item of iterable. You would probably think using for loop as the first like below.

   def for_loop():
      number_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
      square_list = []
      for number in number_list:
         square_list.append(number ** 2)
      print(f"squared => {square_list}")

Adding the main method:

   if __name__ == "__main__":
      for_loop()

We would get this output like following while the code above is run.

Output:
squared => [1, 4, 9, 16, 25, 36, 49, 64, 81]

Alright! Let us code the better one. We are going to code again for loop as single line.

   def loop_fun():
      number_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
      square_list = [number**2 for number in number_list]
      print(f"squared => {square_list}")

Output:
squared => [1, 4, 9, 16, 25, 36, 49, 64, 81]

🔎🔎 ⁉️ We can also take the same result without using for loop, by using map(). The following reimplementation of the above instance.

   def square(n):
       return n ** 2

   def map_fun():
      list_number = [1, 2, 3, 4, 5, 6, 7, 8, 9]
      square_list =  list(map(square, list_number))
      print(f"squared => {square_list}")

Output:
squared => [1, 4, 9, 16, 25, 36, 49, 64, 81]

Take a look at the result that's exactly the same with for loop. The square_list gives us the transformation each items of the list_number. Firstly we've implemented the classic for loop method and so changed a bit. And then we put for loop inside of the list, it is about code optimization. And the last we've used the map() function instead of for loop.

👉 So far so good ! And of course not finished yet so we are about to move on the other implementations of map().

‼️ The map() allows the type conversion for instance suppose you have a list that stores string characters. You're also able to type conversion on all items of the list using the map() function.

   def map_fun():
      list_string = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
      list_int = list(map(int, list_string))
      print(f"converted list => {list_int}")

Output:
converted list => [1, 2, 3, 4, 5, 6, 7, 8, 9]

Now try to convert integer to float.

   def map_fun():
      list_int = [1, 2, 3, 4, 5, 6, 7, 8, 9]
      list_float = list(map(float, list_int))
      print(f"converted list => {list_float}")

In the code above we have passed the type as parameter to the map() so the type of all items has changed.

Let us continue to the instances. In the next one we are going to use another callable method in the map(). There are some built-in functions that you can use in the map().

   def map_fun():
      list_numbers = [-5, 2, -8, 11, -2.17, -1.99, 6, 4]
      abs_list = list(map(abs, list_numbers))
      print(f"abs values => {abs_list}")

Output:
abs values => [5, 2, 8, 11, 2.17, 1.99, 6, 4]

❓❔ What if we try to use lambda in the map function.🤔 Of course we do! Go back above the 'square' example and implement the lambda expression like following.

   def map_fun():
      number_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
      list_square = list(map(lambda number: number ** 2, number_list))
      print(f"lambda squared => {list_square}")

Output:
lambda squared => [1, 4, 9, 16, 25, 36, 49, 64, 81]

Yes, It works ‼️
Let's show how useful method lambda is by one more example. Sometimes we need to do some process like addition, substruction etc. between two lists. In those times we can just use the map() with lambda.

   def map_fun():
      list_num_1 = [8, 4, -7, 3, -2]
      list_num_2 = [3, -1, 9, -3, 5]

      list_sum = list(map(lambda t1, t2: t1+t2, list_num_1, list_num_2))
      print(list_sum)

Output:
sum of the lists => [11, 3, 2, 0, 3]

   def map_fun():
     fruits = ["apple", "banana", "grape", "melon", "avocado", "mango", "orange"]
     upper_fruits = list(map(lambda fruit: fruit.upper(), fruits))
     capitalize_fruits = list(map(lambda fruit: fruit.capitalize(), fruits))
     print(f"UPPER => {upper_fruits}")
     print(f"Capitalize => {capitalize_fruits}")

Output:
UPPER => ['APPLE', 'BANANA', 'GRAPE', 'MELON', 'AVOCADO', 'MANGO', 'ORANGE']

Capitalize => ['Apple', 'Banana', 'Grape', 'Melon', 'Avocado', 'Mango', 'Orange']

‼️ Note that you can use the functions that can get arguments as parameter like strip(), split() etc.

   s_m = ["string/", "manipulation/"]
   list_string = list(map(lambda t: t.strip("/"), s_m))
   print(f"list string => {list_string}")

Output:
list string => ['string', 'manipulation']

👉 Another way to manipulation list that stores string item without using lambda is str method.

   fruits = ["apple", "banana", "grape", "melon", "avocado", "mango", "orange"]
   upper_fruits = list(map(str.upper, fruits))
   capitalize_fruits = list(map(str.capitalize, fruits))

   print(f"UPPER => {upper_fruits}\nCapitalize => {capitalize_fruits}")

Output: 
UPPER => ['APPLE', 'BANANA', 'GRAPE', 'MELON', 'AVOCADO', 'MANGO', 'ORANGE']

Capitalize => ['Apple', 'Banana', 'Grape', 'Melon', 'Avocado', 'Mango', 'Orange']

   s = "string manipulation using map"
   list_split = list(map(str.split, s))
   print(f"split => {list_split}")

Output:
split => [['s'], ['t'], ['r'], ['i'], ['n'], ['g'], [], ['m'], ['a'], ['n'], ['i'], ['p'], ['u'], ['l'], ['a'], ['t'], ['i'], ['o'], ['n']]

On the other hand the lambda can be quite useful about dictionaries in the map().

   def map_fun():
      car_trademarks = {
          "car1": "BMW",
          "car2": "Audi",
          "car3": "Bentley",
          "car4": "Mercedes",
          "car5": "Porsche"
          }
      trademarks_list = list(map(lambda index: car_trademarks.get(index), car_trademarks))
      print(trademarks_list)

Output:
the car list => ['BMW', 'Audi', 'Bentley', 'Mercedes', 'Porsche']

Alright ! The last we are going to write our own module using OOP approach. The module returns string message containing information about given string whether palindrome is or not.

   class Palindrome(object):
      def __init__(self, str_obj):
          self.list_obj = list(map(lambda t: t.strip(), str(str_obj)))

      def _isPalindrome(self):
          list_temp = self.list_obj
          list_temp = list_temp[::-1]
          if list_temp == self.list_obj:
              return True
          return False

      def __str__(self):
          if self._isPalindrome():
              return f"The object {self.list_obj} is palindrome !"
          else:
              return f"The object {self.list_obj} is not palindrome !"

The class takes single string argument and compare with its reverse using list. If it's the same this is palindrome, if it's not the same this is not palindrome.
👉 Adding the main method to run the class Palindrome.

   if __name__ == "__main__":
      string = "tenet"
      p = Palindrome(string)
      print(p)

And the output will probably be like following:

Output:
The object ['t', 'e', 'n', 'e', 't'] is palindrome !

Image Processing in Python / Stage 2

Enes Karataş — Sat, 18 Sep 2021 16:10:39 +0000

❗❗ This section is the second part of before hence you should read before post. We are going to continue from the last of first.

📌

CROPPING IMAGE

We are going to start with cropping image. When an image is to be cropped, a region will be needed to define the area to be cropped. Let's code it !

   image = Image.open("tux.jpg")
   box = (250, 200, 550, 600)
   cropped = image.crop(box)
   cropped.show()

We have opened tux.jpg as the first so, the box is the region to use when we crop the image. As the last we passed the box as parameter to crop() method. You probably are going to get output like this:

ROTATING IMAGE

We can also rotate image using pillow like a media player. Rotate() method does this by taking integer or float angular value as parameter.

   image = Image.open("tux.jpg")
   rotated = image.rotate(90)
   rotated.show()

You will get this output after run the code above.

MERGING IMAGE

The other one property of PIL is merging. This allows us to merge two images. At this time we are going to use 2 different images. One of them is our tux.jpg and the other is new one, tux1.jpg. Let's code it !

   image_1 = Image.open("tux.jpg")
   image_2 = Image.open("tux2.jpg")
   position = (350, 480)
   image_1.paste(image_2, position)
   image_1.show()

In the code above we have defined two images and also position as tuple. Position is used to define where to merge the image. After defining the position we have used paste method and given its parameters, position and image.

After running out the code above we get this output:

Output:

COLOUR TRANSFORMATION

We can change the colour that image has based on the mods. For instance if we look at the coloured image modes we probably see the result RGB. So we need to change this mode by another one. Alright let's try to change the mode RGB by L.

   image = Image.open("tux.jpg")
   img = image.convert('L')
   img.show()

The code above changes the modes of image by 'L'. If we show the image the output will be greyscale.

Output:

On the other hand we also have changed the mode then let's check out the mode of image. The output will be L.

   print(img.mode)

Output:

'L'

So far so good ! Alright now suppose you have an image has RGB mode and you can separate the image to subimages. Each image of subimages has a mode from the image mode. To be able to do this we need to use split() method.

   image = Image.open("tux.jpg")
   red, green, blue = image.split()
   print(green.getbands(), green.getbands(), blue.getbands())

Output:

   ('L',) ('L',) ('L',)

In the code above we have separated the image as red, green, blue. However, Although their bands are the same they are not the same as each other so that they have different colour scale. Try using show() method to see difference. :)

IMAGE ENHANCEMENTS

Sometimes we may want to change some properties of the image while working on. So, ImageEnhance from PIL is the better way to adjusting some properties like contrast, color, brightness, and sharpnes. To use this method we should import before. The code following demonstrates how to use this method.

   from PIL import ImageEnhance

   image = Image.open("tux.jpg")
   enhancer = ImageEnhance.Sharpness(image)
   enhancer.enhance(50.0).show()

You will see the output below.

Output:

Let's adjust the contrast of image now.

   enhancer = ImageEnhance.Contrast(image)
   enhancer.enhance(2).show()

Output:

What If we change the brightness ? 🤔

   brightness = ImageEnhance.Brightness(image)
   brightness.enhance(3.0).show()

Output:

IMAGE FILTERING

Another super cool thing we can do with Pillow is filtering images. There are several filters that pillow provides us like following.

- BLUR
- CONTOUR
- DETAIL
- EDGE_ENHANCE
- EDGE_ENHANCE_MORE
- EMBOSS
- FIND_EDGES
- SHARPEN
- SMOOTH
- SMOOTH_MORE

Once we import the ImageFilter module from PIL we can do something on the image like following.

   image = Image.open("tux.jpg")
   cont_image = image.filter(ImageFilter.CONTOUR)
   cont_image.show()

In the code above we have added the first filter to the image that is CONTOUR. We probably get this output while we run out he code:

Let's try one more of filter details. For instance let us take BLUR at this time and look at what does it look like.

   fedge_image = image.filter(ImageFilter.FIND_EDGES)
   fedge_image.show()

Output:

Image Processing in Python

Enes Karataş — Sat, 18 Sep 2021 16:10:23 +0000

Start Tutorial

📌
In this post I am going to share some information about what image processing is. So, let's begin with the main methodology of image processing.
Firstly, we are going to start with the definition of image processing.

❗❗ Note that this tutorial will be published as a serie hence I recommend you to read the rest of all.

What is image processing ?

✏
Image processing is the manipulation of images in digital environments💻 over some programming languages through some algorithms. We can analyze the images and also transform some properties like colour and dimensions. Apart of that we can categorize the image like RGB and Grayscale image. Also look here

Alright it is time to look at how can we handle that process. At this point we are going to use python. Python is one of the best programming languages to image processing so that we will use some modules of python language.

The list of modules that we will use is;
📋

Pillow(PIL)
OpenCV
NumPy
Sckit-Image

Note that some of those modules will be used less than the others.
Let's start the first of list above.

📍PIL(Pillow)

➡ Pillow is one of the most popular module to basic image processing in Python. This module is used for processing the images in its different properties and also is used so commonly by data scientists. The module provides support various image formats and also includes some popular formats like JPEG, PNG.

Alright! We have done so far and let's go to usage of the modules.

To use Pillow we need to install before so, we can do installation via pip:

   pip install Pillow

   python -m pip install Pillow

If you have linux system then you can also use those instructions to installation as following;

   pip3 install Pillow

   python3 -m pip3 install Pillow

Ready to use now ! Let's go to instances of PIL.

📍Usage and Instances for PIL

➡ Now we have Pillow module that imported to python main. It is time to write instances. In python file we firstly import several modules from PIL that we will use. The first it is going to be Image as well.

   from PIL import Image

Image function is imported from PIL so, we are going to use Image function by its open() module firstly. For this tutorial I have prepared linux tux image as you see below and you also are able to find source [here].

   image = Image.open("tux.jpg")

Image is loaded now let's look at some properties of image. One of those properties is image band. Every image has one or more bands. To demonstrate bands of the image we use getbands() function as following.

   image_bands = image.getbands()
   print(image_bands)

You probably will get output like this:

   ('R', 'G', 'B')

Another property is mode. Image has mode which defines the type and depth of a pixel in the image. To obtain the mode of image we are going to do as following.

   image_mode = image.mode
   print(image_mode)

And then the output will be that string "RGB" for this image. There are some modes that Pillow provides below:

📋

1
L
P
RGB
RGBA
CMYK
YCbCr
HSV
I
F

The another property is size, it can change the size of image as you see below.

   image_size = image.size
   print(image_size)

We got this output for image that we have used.

   Output:
   (1000, 1000)

Now we can change the size ! We do that using resize function.

   resized_image = image.resize((400, 400))
   resized_image.save("new_image.jpg")

You probably are going to see a new image called like "new_image.jpg" in the same directory with your python code file.

So far so good !

Alright it's time to use of functions that can make more complex process on the images. We are going to use some of them in second section of this serie.

The following series allows you to access the other sections.

Image Processing: How to read image from string in python ?

Enes Karataş — Thu, 26 Aug 2021 13:32:48 +0000

Reading image from string base64

🚩 In this tutorial we are going to investigate together how to read image string base64 in python language.

To be able to do processing on image in python some of modules should be used. We are going to use PIL to demonstrate image at this point.

Let's code it !

To get an image as string we need to convert base64 format firstly. Python base64 module is also used for this process.

Let's start with importing the required modules.

👉 ```python

import base64
import io
from PIL import Image


That's it !
So, the first we are going to convert image to base64 using python. Let's do it !

👉
```python


   def read_string():
      with open("tux.jpg", "rb") as image:
          image_string = base64.b64encode(image.read())

      return image_string

I have used a local image "tux.jpg" so, you can use anything that has true image format. Let me clarify the codes above.

Step 1: I have defined function read_string() and opened the image in rb mode. The variable image_string that inside of the function holds base64 string.

👉



   if __name__ == "__main__":
       base64_string = read_string()
       print(base64_string)

When I call the function in the main method we probably are going to get an output like this:



   b'/9j/4AAQSkZJRgABAQAAAQABAAD/7QBsUGhvdG9zaG9wIDMuMAA4QklNBAQAAAAAAE8cAVoAAxslRxwCAAACAAAcAnQAO8KpIFNvZmlhWW91c2hpIC0gaHR0cDovL3d3dy5yZWRidWJibGUuY29tL3Blb3BsZS9zb2ZpYXlvdXNoAP/bAEMAAwICAwICAwMDAwQDAwQFCAUFBAQFCgcHBggMCgwMCwoLCw0OEhANDhEOCwsQ

....

/5W09f+V+gfFfqHxX6h8V+ofFfqHxX6h8V+ofFfvHxX7x8V+8fFfvHxU6Y9FblW4A0P8Aj2//2Q=='

It's too long as you see but there is no problem. Not too big data to process on programming language !

Let's decode the image base64 string vice versa.

👉



   def decode_base64():
       base64_string = read_string()
       decoded_string = io.BytesIO(base64.b64decode(base64_string))
       img = Image.open(decoded_string)
       return img.show()

I have used the other function inside this function to get image string and the other function returns image string as you know. Anyways so base64_string variable holds image string in base64 format and decoded. The last I have used Image function from PIL to show image.

👉



   if __name__ == "__main__":
       decode_base64()

When I call the function decode_base64() the image will be open.

Output:

The entire code is shared below:
👉



import base64
import io
from PIL import Image


def read_string():
    with open("tux.jpg", "rb") as image:
        image_string = base64.b64encode(image.read())

    return image_string

def decode_base64():

    base64_string = read_string()
    decoded_string = io.BytesIO(base64.b64decode(base64_string))
    img = Image.open(decoded_string)
    return img.show()



if __name__ == "__main__":
    base64_string = read_string()
    print(base64_string)

    decode_base64()

How to make code faster in Python ? Some tips about make faster the code

Enes Karataş — Fri, 13 Aug 2021 16:13:06 +0000

Step 1: Why do we need fast code ?

Sometimes we want the codes to run fast however it is not possible without clean codes. In this tutorial we are going to see how to make codes useful and compare them each other.

It is not only speed that matters here. We should determine the system requirements of the code by the system that will work on it. At this point we need to reduce the cost of the program for hardware and make faster.

Alright, suppose that there are two loops which iterate 100_000_000 times as follows:

    i = 0
    while i < 100_000_000:
        i += 1
        pass

and

    for i in range(100_000_000):
        pass

These codes do nothing as well so, their logics are the same. The execution time would be different so that one of them is while the other for loop. Of course it depends on its place of use in the program. So we are going to compare their execution time in the both while loop and for loop. So that we need a python method to do that. This is 'timeit' library. Let's look at how timeit works.

Step 2: Timeit Method

In this section we are going to see how to measure execution time of the functions and also discuss on that times.

The first let's look at the timeit. Surely I am going to begin with that question, What is the timeit ?
Timeit is a method in Python that provides a way to measure execution time of the functions. So we need to use this method when we want to get execution time of any function and also to check performance of codes. That means the execution time can be very important to refactoring and clean code.
Big projects consist of the small functions and methods so that either CPU or RAM cost of the functions should be
optimal to efficient use.
Let's figure out the syntax of timeit.

Syntax:

timeit.timeit(stmt, setup, timer, number)

There are various parameters that passed to timeit method above. We are going to investigate each other step by step.

Let's have a look at the parameters.

stmt:

The parameter takes the code which you have defined before. The default is 'pass'.

setup:

Statement setup details to be executed before running the stmt. The default is 'pass'.

timer:

The parameter takes timer value as a default timer. Note that we will pass this parameter so, the number and stmt are what we need in this tutorial.

number:

Number is the number of the execution number of the code which you defined as stmt.

So far so good !

Now we need to learn how to use timeit in python. Let's start exploring to code of the method. To work with timeit
we need to import that method. The first let me show how to import timeit.

As shown below we import like that:

   import timeit

So, in the following example a while loop is defined in a function that called as while_loop. The function returns sum of numbers up to 100,000,000

     def while_loop(n=100_000_000):
         c = 0
         t = 0
         while(c<n):
             t += c
             c += 1
         return t

The next one is main method in if scope:

      def main():
          print("while loop execution time => \t",  
                      timeit.timeit(while_loop, number=1))

and

     if __name__ == "__main__":
          main()

Finally end of the code ! We probably would get this output.

     Output:
     while loop execution time =>     13.3874618

Alright, the CPU model is Intel Core i5 3337U on the PC. If you use better one then you can see less time. What if you have the same thing in for loop?

     def for_loop(n=100_000_000):
          s = 0
          for i in range(0, n):
               s += i

          return s

   Output:
   for loop execution time =>       7.5061377

Quite easy to explain this difference between while and for loop. It's range method. The range() function is written for python so that provides quite speed to loop. Suppose we check again the number n and increase c that inside of for loop.

     def for_loop_with_check_and_inc(n=100_000_000):
          t = 0
          c = 0
     for _ in range(0, n):

          if _ < n :
              c += 1
              t += _
     return t

     Output:
     for loop execution time =>       18.310060200000002

As you see if statement inside of the loop makes slow quite the code.
Alright let's do something else now. We are going to range() sequence again however inside of the sum() method. We now that before the range() provides immutable number sequence so that if we use range inside of the sum we probably are going get the sum of each number.

    def sum_range_without_loop(n=100_000_000):
         return sum(range(n))

    Output:
    sum method execution time =>       4.478143

What a huge difference according to for or while loops! Output is execution time of the sum of the first 100,000,000 number I mean the same with before functions but look at this difference.
Alright there is another way to use number sequence like range this is numpy.arange(). And we would also use numpy.sum method instead of the sum(). Before using this method we need to import numpy.

     import numpy as np

     def numpy_arange_sum(n=100_000_000):
          return np.sum(np.arange(n))

We get the following output.

   numpy sum and arange execution time =>         0.3317797

The best time of all ! So, the whole features of numpy library are written in C language so that provides more efficient ram usage and executes so quick.

Finally, the module is used for to find out execution time of small codes. If you intend to use timeit just import module firstly. Thats sufficent to use module. Note that in different systems that have distinct hardware the time results will be different.

To more information please go to link below.

Sources

You can also find my github here.