DEV Community: carrot.py

Sneak peak into Git LFS(Large File Storage System)

carrot.py — Sat, 24 Dec 2022 18:40:46 +0000

Hi Folks,

Yes! I'm back with an interesting blog Git LFS- An file storage system by git (basically to store large files above 100Mb)

A small back story How I came to know about this!

Recently my colleague asked me Have you ever worked in git Lfs ? I just ignored him like this and get back to my work
Lately, my Manager told us to push changes we were working on for a month(it includes 500Mb of CSV and txt files) when we try to Push it to the remote
git tell us this

Yes! it throws the error Files with larger size should be tracked through LFS,

it almost spoiled our holiday eve!!
After spending almost a day, we figured out what is Git LFS and how to push the files!!!!
Here are some Steps to start with Git LFS and some important points so that it won't spoils Your Holiday eve

What is Git LFS?

Git Large File Storage (LFS) replaces large files such as audio samples, videos, datasets, and graphics with text pointers inside Git while storing the file contents on a remote server

OK, Enough is Enough!
Let's Push Files!

Before getting started we need to install git LFS!
if you are a Mac user use

brew install git-lfs

for other os platforms please refer this
In my case, I gonna initiate new repo and some dummy files with 200Mb size

Now let's add the 200Mb into LFS

I assume you know basic git actions(add, commit,push)

Step-1: This command will set up the Git LFS in your current repo

git lfs install

Step-2: We need to tell git which type of files or which files needed to be tracked to LFS. The below command will create .gitattributes file contains a list of tracked files

git lfs track "*.csv"

For example:

if You are working in psd files and need to add all the psd files in LFS means you will give a pattern like "*.psd"
OR
if you need to add all the file under some folder You can give like path/folder_name/** this will add all the files under the path

Step-3: Now add the .gitattributes and commit it as we do before

git add .

git commit -m "initial commit"

This will add all the changed files to the stage and commit those!

Step -4 : Make sure that all Your files are tracked in LFS use the below command to see the list of tracked files

git lfs ls-files

Step -5 : Let's push use the command to push the large file First

git lfs push --all origin <branch>

Then regular push

git push origin

Tada, it's all done!

Points to remember!

Make sure the file format is correct and not corrupted
Files above 100 MB should be added via Git LFS below that we can add through regular git actions

Thanks, @iamadhee (Lol! he is the colleague I ignored)

Thanks! folks Thanks for reading
Let me know your experience in comment section after using git LFS and the struggles you faced, I will try to post the fix :)

Algorithms and Data structure- A heads up

carrot.py — Thu, 06 Oct 2022 14:51:24 +0000

Hi Folks,

Before getting into it we all have come across the word saying "what algorithm you used to solve this problem?" and our answer obviously is

This Blog-series talks about the basics of algorithms and DS(Data Structure), this blog will give you a little heads up on Algorithm ok let's learn algo(awɡu)

what is Algorithms?

An algorithm is any well-defined computational procedure that takes some value, as input and produces some value, or set of values, as output. An algorithm is thus a sequence of computational steps that transform the input into the output.

In simple terms let's say you need to drop your friend at the Railway station before 10 pm, For that you need to build an algorithm to find the Shortest Route (which is your output), you would consider their parameters the distance, number of alternative routes, speed, traffic and time(these are your input) using which you can do some analysis and come up with the shortest route

likewise, the algorithm is a series of steps that is implemented with the given input to get the desired output.

why the Algorithm is needed to solve a problem?

From the above example if you go on your wish you cant drop your friend at the correct time, similarly, a computational operation working on an algorithm can give you the desired output efficiently

What is a Data structure?

A data structure is a way to store and organize data in an ordered fashion. so that it's easy to access and manipulate

it's good to learn many DS as possible so that it's easy to build or implement an algorithm

Algorithm in real-life!

we might wonder are we using those in real life! the answer would be yes and some of the examples are

Search algorithms- When we search a file in folder or a link in the internet it uses any of the famous search algorithms to get the result at minimal time
E-commerce - Technologies used in electronic commerce include encryption and digital signatures which are based on numerical algorithms

To sum up These are some Infos to know about Algorithms and DS we will see more about them in later part of the Series

Thank You!!

LET'S HIT. (A blog post about Fast Api)

carrot.py — Wed, 25 May 2022 08:25:30 +0000

Hi Guys!

We are all know about API and of course some of us have used it already and some of us are building it already in different languages. Here we lets see about Fast Api(one of the popular api module in python),why its so popular?,Its Pros and How to build it!

Let's HiT🔥🔥

At First What is Fast Api?, why Fast Api? ,we have well established frameworks in python like Django, Flask why we need to use Fast Api?
What is Fast Api?
FastAPI is an ASGI web framework

Why Fast Api?

Here some of reason to use Fast Api stated by the creator
Fast: Very high performance, on par with NodeJS and Go (thanks to Starlette and Pydantic). One of the fastest Python frameworks available.

Fast to code: Increase the speed to develop an api

Fewer bugs: Reduce about 40% of human (developer) induced errors
Intuitive: Great editor support. Completion everywhere. Less time debugging.
Easy: Designed to be easy to use and learn. Less time reading docs.
Robust: Get production-ready code. With automatic interactive documentation

The feature i really like about Fast Api is documentation, offered by (Redoc and Swagger UI) its very Easy to debug and Test the Api you build!! Alright. Story time ends Here!! its time to build One

Its Hero time😅!

1.initially lets create an virtual environment

syntex:python3 -m venv <path you wish to create>

Eg:python3 -m venv /Users/d.r/carrotpy/

2.Now a Folder is created at the path you specify, open the folder in any of the IDE (says VS-Code since its Famous)

In order to use venv we need to activate it
navigate into the folder and give the command

syntex: source bin/activate

Eg:

3.Install the Fast Api and uvicorn into the venv

pip install fastapi

pip install uvicorn

4.Here the code to get the vegetable name and count from the user and return it

from typing import Optional
# if we need some parameter to be optional we use typing
import uvicorn
#it is ASGI
from fastapi import FastAPI
#importing Fast Api
app = FastAPI()
#declaring Fast Api

#start of Decorators
#When you hit the address http://127.0.0.1:8000/ This will return {"Hello": "World"}  as dict 
@app.get("/")
def carrotgreetings():
    return "Hello Rabbit"

# this will retun the vegtable name and its count
@app.get("/veglist/{vegtable}/")
def read_item(vegtable: str, count: Optional[str] = None):
    return {"vegtable": vegtable, "count": count}

if __name__ == "__main__":
    uvicorn.run("fastapi_demo:app", host='127.0.0.1', port=8000, reload=True)

5.Run the Code by the comment

Syntex:`python3 <filename>`

Eg: python3 fastapi_demo.py

now hit the api by clicking http://127.0.0.1:8000/

You can see the docs by http://127.0.0.1:8000/docs

You can pass the Vegtable names and count by
http://127.0.0.1:8000/veglist/carrot/?count=2

wow! we made the api....