DEV Community: Audarya

Beginners guide to start using Vim

Audarya — Tue, 27 Sep 2022 18:22:24 +0000

Hello Vim !

This blog or you can say cheat-sheet covers the basic commands/keys you need to know to start using Vim. Initially, you will feel that it's a lot to remember but just keep practicing. The first day you'll hate it. In a week you'll understand it and by a month you'll start loving it.

The best way to utilize this cheat-sheet is to open/create a file via Vim and practice these commands one by one.

So lets begin 🚀

Exiting

:w - save file

:wq - save and quit (can also use :x)

:q - quit

:q! - quit without save

:qa! - close all files and abandon changes
ZZ - save and quit

Navigating

arrows - to navigate up down left right

l - right

h - left

j - down

k - up

Document

} - move down 1 block of code

{ - move up 1 block of code

gg - move to top of file

G - move to bottom of file

:<num> - go to line <num>

Words

w - move to next word on the line

b - move to previous word on the line

ge - move to previous end of word
e - move to next end of word

Line

0(zero) -move to beginning of the line

$ - move to end of the line

^ - move to first character of the line

t<char> - move cursor just before <char> on the line

f<char> - move cursor on the <char> on the line

% - move cursor to matching ),], or }

Clipboard

x - delete character
<num>x - delete <num> characters to right of cursor

dd - delete current line(cut)
yy - yank line(copy)

p - paste below

P - paste above

u - undo

ctrl R - redo

Modes

i - enter insert mode

esc - escape any mode and enter command mode

o - insert 1 line below and enter insert mode

O - insert 1 line above and enter insert mode

V - visual mode (selects 1 line per movement)

v - visual mode (selects 1 letter per movement)

V + d - delete selected part

ctrl V + movements - selects column

Misc Operators and combos

cw - change word -> it deletes a word and enters insert mode

dw - delete to next word

db - delete to beginning of word
D - deletes everything to right of cursor

C - deletes everything to right of cursor and enter insert mode

dt<char> - delete till <char> excluding <char>

ct<char> - delete till <char> excluding <char> and enter insert mode

* - toggle between instances of the word where the cursor is present

t<char>; - move to <char> on the line on every press of ;

zz - scrolls the page such that the line on which the cursor is right now is brought to center of page...i.e. centers the work page

0w - move to first character of line

d<num>w - delete <num> words

a - move right by 1 letter and enter insert mode

A - move to end of line and enter insert mode

~ - toggle case of word (uppercase/lowercase)

. - re runs the last command

r<anything> - replace current letter to <anything>

>> - indent current line

<< - remove indent from current line

Wrap Up

There is a lot that I haven't covered yet like macros, complex combos, plugin setup, configuring vim and many other keybindings. This blog is just meant to be for beginners. Once you get comfortable with Vim it's easy to explore these and try it out.

I hope you found this cheat-sheet helpful and keep it handy for a quick reference. If you want me to add more information in this blog or need any help let me know in the comments.

Let's connect on LinkedIn

👋 Thanks for reading, See you next time.

Getting Started With Redis And It's Data Types On Redis-CLI

Audarya — Mon, 31 Jan 2022 07:38:54 +0000

REDIS (REmote DIctionary Service)

What is Redis?

Redis is an open source, in-memory data structure store, used as a database or as a cache. Redis provides data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, streams and much more.

You can run atomic operations on these types, like appending to a string; incrementing the value in a hash; pushing an element to a list; computing set intersection, union and difference; or getting the member with highest ranking in a sorted set.

Redis is written in ANSI C and works in most systems like Linux and OS X, without external dependencies. Linux and OS X are the two operating systems where Redis is developed and tested the most, and it is recommended to use Linux for deployment. There is no official support for Windows builds.

Use cases of Redis

Queues
Publish/Subscribe (Pub/Sub)
Real-time analytics
Geospatial processing
Leaderboards/counting
Session Cache
Full page cache

Redis Installation

For Windows Though Redis is not supported on Windows, we can have a workaround for it.
Enable WSL from "Turn Windows features on or off settings"
Restart the machine
Install Ubuntu20.04 from Windows Store
Open Ubuntu App and setup name and password
Run the following commands:

sudo apt update

sudo apt upgrade

sudo apt install redis-server

sudo service redis-server restart

redis-cli
For Linux

Redis installation on Linux is super easy.

Run the commands:

sudo apt install redis-server

sudo service redis-server restart

redis-cli

The command redis-cli will start the redis command line on which we will be interacting with redis store.

Common Redis Commands

NORMAL USAGE AS A KEY VALUE STORE

SET *key value* => Set a key value pair
GET *key* => Get a value by searching for corresponding key
TTL *key* => Time To Live is the expiry(time left) of the key
KEYS *regex* => To search for the pattern of keys. Common usage: KEYS *
DEL *key* => Deletes the key if present
FLUSHALL => Remove all keys present
EXISTS *key* => Returns 1 if key is present else return 0
EXPIRE *key time*(in sec) => Sets expiry time to the key if it exists
SETEX *key time value* => Sets a new key value pair with given TTL

LIST/ARRAY

Redis Lists are simple lists of strings, sorted by insertion order. We can add elements from the left or right end of the list.

LPUSH *arr val1 val2 val3 ....* => Left push in arr(key) values val1, val2 ....
RPUSH *arr val1 val2 val3 ....* => Right push in arr(key) values val1, val2 ....
LRANGE *arr start stop* => Return elements of arr from index range start to stop
LPOP *arr* => Pop leftmost element of list
RPOP *arr* => Pop rightmost element of list

SET

Redis Sets are an unordered collection of unique strings. Unique means sets does not allow repetition of data in a key.

SADD *key val1 val2 ...* => Adds one or more values to a set
SMEMBERS *key* => Gets all the members in a set
SCARD *key* => Gets the number of members in a set
SREM *key val1 val2 ...* => Removes one or more members from a set

OBJECT/HASH

Redis Hashes are maps between the string fields and the string values. Hence, they are the perfect data type to represent objects. In a lot of ways, we can think of HASHes in Redis as miniature versions of Redis itself.

In Redis, every hash can store up to more than 4 billion field-value pairs.

HSET *key field value* => Sets field in hash stored at the key to value
HGET *key field* => Gets the value of a hash field stored at the specified key
HGETALL *key* => Gets all fields and values stored in a hash at the specified key
HDEL *key field* => Deletes one or more hash fields
HEXISTS *key field* => Determines whether a hash field exists or not

P.S : The commands listed for the above data types are not all. There are a lot of other commands which can be found on the redis official website.

Resources And References

The official website of Redis is the most awesome resource I have found to know anything about using Redis and it's commands: https://redis.io/commands

Also this cheat sheet I found on the web: Link

Wrap Up

I hope you found this blog helpful and keep it handy for a quick reference. If you want me to add more information in this blog or need any help please let me know in the comment section.

Let's connect on LinkedIn

👋 Thanks for reading, See you next time.

Important PostgreSQL Concepts - 16 psql Command-line Utilities You Don't Want To Miss And A Lot More

Audarya — Thu, 06 Jan 2022 16:46:26 +0000

PostgreSQL is one of the most advanced database in the open source relational database market.According to db-engines, it is the fourth most used database at the time of writing.

This blog is more of a cheat sheet to quickly know about PostgreSQL and get started with it.

So...lets get started !!

Features of Postgres

It is an object relational database.
It handles concurrency better than MySQL.
It implements Multiversion Concurrency Control (MVCC) without read locks.
It protects data integrity at transaction level.
Less vulnerable to data corruption.
Supports parallel query plan that can use multiple CPU/cores.
It can create partial indexes.
It can create indexes in non-blocking way.
Allows us to add our own datatypes, operators and index types.
Capable of writing large amounts of data more efficiently.
It supports table inheritance.

Disadvantages of Postgres

Slow for read-heavy operations compared to MySQL.
It forks a new process for each new client connection which allocates a non-trivial amount of memory (about 10 MB).

PS: If you found some words fancy in the above list, I would suggest you to quickly google about it to get an idea. This tip applies to everything in this blog. You can mention these points in your interviews as well 😎

Server and database objects provided by PostgreSQL

Server service
Databases -> container of objects like tables, views, functions, indexes.
Tables -> Stores actual data. Belongs to a database.
Schema -> Logical container of table and other objects.
Tablespaces - place where data is stored physically Provides 2 default tablespaces:
- pg_default -> for storing user data
- pg_global -> for storing system data
Views -> views are named queries stored in the database.
Functions
Operators
Casts -> to convert one datatype to another.
Sequence -> used to manage auto-increment columns in a table.

Evaluation order in Queries

The following sequence shows the decreasing priority(from left to right) given to different clauses in a complex SQL Query.

FROM --> WHERE --> SELECT --> ORDER BY

Most Used Clauses

IN - Returns true if a value matches any value in the list
BETWEEN - Return true if a value is between a range of values ex. BETWEEN 3 AND 5
LIKE - Return true if a value matches a pattern ex. LIKE 'Aud%' means match string starting with 'Aud'.
ILIKE - Same as LIKE but case insensitive pattern matching. Notation (~~*)
OFFSET - Skip a number of rows before returning the resultset
LIMIT - To constrain the number of rows returned by a query (not a SQl standard)
FETCH - Same as LIMIT and it a SQL standard. Syntax -> FETCH {FIRST|NEXT} row_cnt {ROW|ROWS} ONLY
LEFT(s, n) - Extracts first n characters from s
ALL - We can use the word ALL to allow >= or > or < or <= to act over a list ex. on result of select subquery
ORDER BY - Sort thr column in ASC or DESC order
GROUP BY - Functions such as SUM and COUNT are applied to groups of items sharing values.ex."GROUP BY continent" ,the result is only one row for each different value of continent. All the other columns must be "aggregated" by one of SUM, COUNT etc.
WHERE - filters the rows before aggregation operation
HAVING - filters after the agregation

Some important psql commands

sudo -u <role name> psql -> switched to and starts psql command prompt
\c dbname username -> switch connection to new database (dbname) under a user specified by
\l -> list all available databases
\dt -> list all tables in current database
\d table_name -> describe a table
\dn -> list all Schemas of current database
\df -> list all functions of current database
\dv -> list all Views of current database
\du -> list all users and their assigned roles
psql -h localhost -U username db_name; -> switch user and database
\s -> to display command history
\g -> to execute previous command
\i filename -> to execute psql commands from a file
\timing -> to turn ON/OFF query execution time:w
\e -> to write command in default editor(vim/nano)
\q -> to quit psql

Common Queries

Create new user -> CREATE USER <username> WITH PASSWORD 'password';
Drop user -> DROP USER IF EXISTS <username>;
Create new database -> CREATE DATABASE <db_name>;
Grant privileges -> GRANT ALL|SELECT|UPDATE|DELETE PRIVILEGES ON DATABASE <db_name> TO <username>;
Drop database -> DROP DATABASE IF EXISTS <db_name>;
Create schema -> CREATE SCHEMA <schema_name> [CASCADE];
Create table -> CREATE TABLE <tb_name>;
Insert data -> INSERT INTO tb_name(col1, col2,...) VALUES (val1, val2,...);
Update Column -> UPDATE <tb_name> SET col_name = value WHERE <condition>;
Delete row -> DELETE FROM <tb_name> WHERE <condition>;
Delete table -> DROP TABLE IF EXISTS <tb_name>;

Resources And References

This is one of the most awesome resource I have found to know anything about using PostgreSQL:

https://www.postgresqltutorial.com/

Wrap Up

I hope you found this cheat sheet helpful and keep it handy for a quick reference. If you want me to add more information in this blog or need any help please let me know in the comment section.

Let's connect on LinkedIn

👋 Thanks for reading, See you next time

The Ultimate Guide You Need To Publish Your Python Package In Just 9 Easy Steps

Audarya — Sun, 26 Dec 2021 18:18:34 +0000

Directory structure

Create a directory that is named exactly how you want your package to be named.
Place all the files, folders and classes that you want to publish into this directory.
Create files required by PyPI to prepare the project for distribution.
It should look something like this:

Clean your code

Remove all "print" statements from the code.
Use logs instead of print statements(debug/info/warn etc..)

Configuring metadata

setup.cfg --> It is the configuration file for setuptools. It tells setuptools about your package(such as the name and version) as well as which code files to include. There are a variety of metadata and options supported here.

[metadata]
description-file = README.md

setup.py --> It is the build script for which tells setuptools about your package(such as the name and version) as well as which code files to include.

setuptools is a library designed to facilitate packaging Python projects.

Open setup.py and enter the following content. Change the name to include your username; this ensures that you have a unique package name and that your package doesn’t conflict with packages uploaded by other people.

from setuptools import setup, find_packages

version = '0.0.1' # Any format you want

with open("README.md", "r", encoding="utf-8") as fh:
    long_description = fh.read()

setup(
  name='your-package-name',
  packages=find_packages(),
  version=version,
  license='MIT',
  description='Short description',
  long_description=long_description,
  long_description_content_type="text/markdown",
  author='Author Name',
  author_email='author@email.com',
  url='https://gitlab.com/username/repo-name',
  download_url=f'https://gitlab.com/username/repo-name/-/archive/{version}/repo-name-{version}.tar.gz',
  keywords=['Some', 'keywords'],
  install_requires=[
          'dependency-1',  # All external pip packages you are importing
          'dependency-2',
      ],
  classifiers=[
    'Development Status :: 3 - Alpha',
    'Intended Audience :: Developers',
    'Operating System :: OS Independent',
    'Topic :: Software Development :: Build Tools',
    'License :: OSI Approved :: MIT License',
    'Programming Language :: Python :: 3.7',
    'Programming Language :: Python :: 3.8',
  ],
)

You can find details about each arguments here.

Creating README.md (optional but recommended)

Open README.md and enter details about your package. You can customize this as you’d like. This content can be displayed on the homepage of your package on PyPI.

Creating a LICENSE

It’s important for every package uploaded to the Python Package Index to include a license. This tells users who install your package the terms under which they can use your package. For help picking a license, see https://choosealicense.com/. Once you have chosen a license, open LICENSE and enter the license text. For example, if you had chosen the MIT license:

Copyright (c) 2021 YOUR NAME
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Create a PyPI account

Register yourself for a PyPI account here. Remember your username (not the Name, not the E-Mail Address) and your password, you will need it later for the upload process.

Upload your package to github/gitlab

Create a github/gitlab repo including all the above files and folders. Name the repo exactly as the package.

If uploading package to Gitlab,

After uploading the required files, go to Repository --> Tags --> New Tag and create new tag(tag name should be same as the version) for every release of the package to PyPI.

This copied link should be the same as download_url argument in the setup.py file.

If uploading package to GitHub,

After uploading the required files, follow steps mentioned here to create a release.

NOTE:

Every time you want to update your package later on, upload a new version to gitlab/github, create a new release as discussed, specify a new release tag and copy-paste the link to Source into the setup.py file (do not forget to also increment the version number).

Uploading the distribution archives

The first thing to do is register an account on TestPyPI, which is a separate instance of the package index intended for testing and experimentation. To register an account, go to here and complete the steps on that page. You will also need to verify your email address before you’re able to upload any packages.

After registration, use twine to upload the distribution packages.

Navigate to folder where you have al the files and package located.
Run python setup.py sdist
Install Twine: pip install twine
Run twine: twine upload --repository testpypi dist/* Upload successful

Installing newly uploaded package

pip install -i https://test.pypi.org/simple/ your-package-name

When you are ready to publish your package to PyPI after proper testing, run the following command:

twine upload dist/*

to publish it on PyPI.

NOTE:

Now for every future updates to your package:

change the version number in setup.py file
create tag/release in gitlab/github
update the download_url in setup.py
Run python setup.py sdist
Run twine upload dist/*
Run pip install your-package --upgrade --> to see whether your changes worked.

AND IT'S DONE ...YAAAY !!

Visit PyPI and search for your package name. Now you can use your package just like any other python packages by installing it with pip i.e. pip install your-package-name.

I hope this blog helped you understand how to publish your own Python Package easily.

Happy coding !!