Hi, I am Mukhtar
I write code and watch Mars documentaries

About me

I am Software Engineer, I writes Python, Go and JavaScript in my day-to-day activity

Whenever I'm not writing code, I watch Mars documentaries, I read historical books. I am also a student of Philosopy and Metaphysics, Politics, Religion, Cultures and Entertainment.

I am a fan of Curiosity Rover and I look forward to seeing Perseverance Rover(Update, it's on the red planet, read more on the beautiful Red planet ♥.
I have a pinch for learning as it gives me the opportunity to see the world in a different way.

Gautama Buddha is one of my favorite thinkers, Aristole, Avicenna, Confucious and Averoes are also my favorite thinkers.

I never see what has been done; I only see what remains to be done (Buddha)
       

My popular code snippets


SQLAlchemy Model Manager

from sqlalchemy.orm import Session
class Manager:
def __init__(self, Model, database: Session):
self.db = database
self.Model = Model
self._query = {} # Instantiate a query, update it on get/filter call
def __str__(self):
return "%s_%s" % (self.__class__.__name__, self.Model.__name__)
def __len__(self):
return self.__fetch().count()
def __iter__(self):
for obj in self.__fetch():
yield obj
def __getitem__(self, item):
return list(self)[item]
def update_query(self, query):
self._query.update(query)
def __fetch(self):
return self.db.query(self.Model).filter_by(**self._query)
def get(self, **query):
self.update_query(query)
return self.__fetch().first()
def filter(self, **query):
self.update_query(query)
return self
def create(self, **kwargs):
obj = self.Model(**kwargs)
self.save(obj)
return obj
def save(self, obj):
self.db.add(obj)
self.db.commit()
self.db.refresh(obj)
def all(self):
return self
view raw manager.py hosted with ❤ by GitHub

Django Task Runner

from celery.utils.log import get_logger
from django.conf import settings
logger = get_logger(__name__)
class TaskRunner:
def __init__(self, func_code, func, args=[], kwargs={}, task_kwargs={}):
self.func_code = func_code # This could be used to save to db
self.func = func
self.args = args
self.kwargs = kwargs
self.task_kwargs = task_kwargs
@property
def _task_kwargs(self):
# retries
retries_policy = getattr(settings, "RETRIES_POLICY")
if not self.task_kwargs.get('retries_policy') and retries_policy:
self.task_kwargs['retries_policy'] = retries_policy
self.task_kwargs['retry'] = True
return self.task_kwargs
def run(self):
try:
return self.func.s(*self.args, **self.kwargs).apply_async(**self._task_kwargs)
except self.func.OperationalError as exc:
logger.exception('Sending task raised: %r', exc)
view raw task_runner.py hosted with ❤ by GitHub

Pytest Auto-login test fixture

import pytest
@pytest.fixture
def password():
return 'my-password-is-stronger-than-yours'
@pytest.fixture
def create_user(db, django_user_model, password):
def _user(**kwargs):
kwargs['password'] = password
if 'username' not in kwargs:
kwargs['username'] = "test_user"
# Un-comment if you use email as USERNAME_FIELD
# if 'email' not in kwargs:
# kwargs['email'] = "[email protected]"
return django_user_model.objects.create_user(**kwargs)
return _user
@pytest.fixture
def auto_login_user(db, client, create_user):
def _login(user=None):
if user is None:
# pass is_superuser, is_staff or other user fields to create_user()
user = create_user()
login = client.login(username=user.username, email=user.email, password=user.password)
if not login:
# Login failed, force login
client.force_login(user)
return client, user
return _login
view raw conftest.py hosted with ❤ by GitHub

Multi Model using Scikit-learn

class MultiModel:
test_scores = {}
train_scores = {}
models = {}
def __init__(self, n_models, typeof):
self.n_models = n_models
self.typeof = typeof
def load(self, X_train, X_test, y_train, y_test):
if self.typeof == 'clf':
# IMPORTING LIBRARIES
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.neural_network import MLPClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.linear_model import SGDClassifier
self.models = {
'KNN': KNeighborsClassifier(n_neighbors=1),
'DecisionTreeClassifiier': DecisionTreeClassifier(max_leaf_nodes=3, random_state=0),
'RandomForest': RandomForestClassifier(n_estimators=100),
'MLP': MLPClassifier(activation='logistic', random_state=3),
'LinearDiscriminant': LinearDiscriminantAnalysis(),
'GradientBoosting': GradientBoostingClassifier(random_state=0),
"SVM": SVC(kernel="linear"),
"Naive_bayes": GaussianNB(),
'SGDPerceptron': SGDClassifier(loss='perceptron'),
'ExtraTrees': ExtraTreesClassifier(n_estimators=100, max_depth=4, random_state=0)
}
elif self.typeof == 'regr':
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Ridge
from sklearn.linear_model import Lasso
from sklearn.tree import DecisionTreeRegressor
self.models = {
'LogisticRegression': LogisticRegression(),
'KNNRegressor': KNeighborsRegressor(n_neighbors=3),
'LinearRession': LinearRegression(),
'Ridge': Ridge(),
'Lasso': Lasso(),
'DecisionTreeRegressor': DecisionTreeRegressor(),
}
modules = list(self.models.keys())
agg_model = modules[:self.n_models]
for x in agg_model:
model = self.models[x]
model.fit(X_train, y_train)
train_score = model.score(X_train, y_train)
test_score = model.score(X_test, y_test)
self.test_scores[x] = test_score
self.train_scores[x] = train_score
return (self.train_scores, self.test_scores)
def check(self, accuracy_scores):
train, test = accuracy_scores
max_test_score = max(list(test.values()))
max_train_score = max(list(train.values()))
max_key_train = [k for k, i in train.items() if i == max_train_score]
max_key_test = [k for k, i in test.items() if i == max_test_score]
print(
'Best train score: {}:{:.2f}%\nBest test score: {}:{:.2f}%'.format(max_key_train, (max_train_score * 100),
max_key_test, (max_test_score * 100)))
def compare(self, accuracy_scores):
train, test = accuracy_scores
print('ACCURACY COMPARISON')
for (model1, accuracy1), (model2, accuracy2) in zip(train.items(), test.items()):
print('{}:{:.2f}% || {}:{:.2f}%'.format(model1, accuracy1 * 100, model2, accuracy2 * 100))
view raw mmodel.py hosted with ❤ by GitHub

Notable projects I've worked on


Django Request Viewer

Log and View requests made on Django
Github
Python   Django  

Oauth2 SSO Server

view
An Oauth2 Single-Sign-On implementation in Go
Github
Go

Loopers

view
A UI implementation of Loopers API.
Used for crawling links
Github
JavaScript   React  Axios

Jallows

view
A Risk Management System for companies, built specifically for The Netherlands
Python  Django  JavaScript  AWS  Celery

Loopers API

view
Loopers API. An API used for crawling links and E-mails
Github
Python   Django  DRF   Loopers

Django Query Playground

view
Play around with Django models using popular queries before running that migrations.
Github
Python   Django   JavaScript   Jquery

Django TalkTo

Django TalkTo allows you to consume RESTful APIs seamlessly without need to create a database table
Github
Python   Django   Django Rest Framework
Send me an email