customeranalytics 0.1__py3-none-any.whl

customeranalytics/utils.py

@@ -0,0 +1,186 @@
+import datetime
+import os
+import inspect
+from os.path import join
+import yaml
+
+from customeranalytics.configs import none_types
+
+
+def current_date_to_day():
+    """
+    recent date of converting to datetime from isoformat.
+    :return: datetime
+    """
+    return datetime.datetime.strptime(str(datetime.datetime.now())[0:19], '%Y-%m-%d %H:%M:%S')
+
+
+def find_week_of_monday(date):
+    """
+    Monday of each week. This helps us to aggregate data per week.
+    :param date: datetime format; %Y-%m-%d %H:%M:%S
+    :return: datetime
+    """
+    week_day = datetime.datetime.strptime(str(date)[0:10], "%Y-%m-%d").isoweekday()
+    return datetime.datetime.strptime(str(date)[0:10], "%Y-%m-%d") - datetime.timedelta(days=week_day-1)
+
+
+def convert_dt_to_day_str(date):
+    """
+    converting date time to str date. e.g; 2020-12-12 00:00:14  - 2020-12-12.
+    :param date: datetime format; %Y-%m-%d %H:%M:%S
+    :return: string date
+    """
+    return datetime.datetime.strptime(str(date)[0:10], "%Y-%m-%d")
+
+
+def convert_str_to_hour(date):
+    """
+    string date is converting to datetime and grabbing hour from it.
+    :param date: datetime format; %Y-%m-%d %H:%M:%S
+    :return: hour [0 - 24)
+    """
+    return datetime.datetime.strptime(str(date)[0:10] + ' ' + str(date)[11:19], "%Y-%m-%d %H:%M:%S").hour
+
+
+def convert_to_date(date):
+    """
+    Convert str date to datetime. If is NULL skip the process and return None.
+    :param date: str format; %Y-%m-%d %H:%M:%S
+    :return:
+    """
+    if date == date and date not in none_types:
+        return datetime.datetime.strptime(str(date)[0:10] + ' ' + str(date)[11:19], "%Y-%m-%d %H:%M:%S")
+    else:
+        return None
+
+
+def calculate_time_diff(date1, date2, period):
+    """
+        -   Calculating total seconds between date1 (start date) and date2 (end date).
+        -   Calculated total seconds is divided to time period.
+    :param date1: start date
+    :param date2: end date
+    :param period: period of time that can be measured a countable number of times between start date and end date.
+    :return: difference float
+    """
+    diff = 0
+    division = (60 * 60)
+    if date1 == date1 and date2 == date2:
+        if period == 'hour':
+            division = (60 * 60)
+        if period == 'day':
+            division = (60 * 60 * 24)
+        if period == 'week':
+            division = (60 * 60 * 24 * 7)
+        diff = int(abs(date1 - date2).total_seconds() / division)
+    return diff
+
+
+def convert_to_day(date):
+    """
+    Convert str date to day.
+    :param date: str format; %Y-%m-%d
+    :return:
+    """
+    return datetime.datetime.strptime(str(date)[0:10], "%Y-%m-%d")
+
+
+def read_yaml(directory, filename):
+    """
+    reading yaml file with given directory
+    :param directory: path
+    :param filename: file name with .yaml format
+    :return:
+    """
+    with open(join(directory, "", filename)) as file:
+        docs = yaml.full_load(file)
+    return docs
+
+
+def convert_to_iso_format(date):
+    """
+    converting iso-format to timestamp Ex: from  2021-01-01T00:00:00 to 2021-01-01 00:00:00
+    """
+    if len(str(date)) == 10:
+        return datetime.datetime.strptime(str(date)[0:10] + ' 00:00:00', "%Y-%m-%d %H:%M:%S").isoformat()
+    if len(str(date)) == 19:
+        return datetime.datetime.strptime(str(date)[0:10] + ' ' + str(date)[11:19], "%Y-%m-%d %H:%M:%S").isoformat()
+    if len(str(date)) != 10 and len(str(date)) != 19:
+        return date.isoformat()
+
+
+def get_index_group(index):
+    """
+    when Exploratory Analysis or Ml Processes work on dimension this will hep us to get exact dimension name.
+    If it is calculating for aLL data, this will return 'main'.
+    """
+    if index in ['orders', 'downloads']:
+        return 'main'
+    else:
+        return index
+
+
+def convert_dt_to_month_str(date):
+    """
+    converting date time to str date. e.g; 2020-12-12 00:00:14  - 2020-12-12.
+    :param date: datetime format; %Y-%m-%d %H:%M:%S
+    :return: string date
+    """
+    return datetime.datetime.strptime(str(date)[0:7], "%Y-%m")
+
+
+def sqlite_string_converter(_str, back_to_normal=False):
+    """
+    when query or path is inserted into the sqlite db, it is need to be convert ''' and removing back slashes.
+    :param _str: query string Ex: " SELECT *  FROm table ..."
+    :param back_to_normal: convert back to normal True / False
+    :return: string query
+    """
+    if back_to_normal:
+        return _str.replace("#&_5", "'").replace("+", " ") + ' '
+    else:
+        return _str.replace("'", "#&_5").replace("\r", " ").replace("\n", " ").replace(" ", "+")
+
+
+def abspath_for_sample_data():
+    """
+    get customer_analytics path. Ex: ....../customer_analytics
+    :return: current folder path
+    """
+    currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
+    base_name = os.path.basename(currentdir)
+    while base_name != 'customeranalytics':
+        currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
+        base_name = os.path.basename(currentdir)
+    return currentdir
+
+
+def dimension_decision(order_index):
+    """
+    Decision of dimension.
+    if order_index = 'Orders' it will be whole data, if it is not it will be executed for a dimension
+    :param order_index:
+    :return: True/False
+    """
+    if order_index != 'orders':
+        return True
+    else:
+        return False
+
+
+def formating_numbers(num):
+    """
+    Human formatting for long numbers as strings
+    """
+    magnitude = 0
+    while abs(num) >= 1000:
+        magnitude += 1
+        num /= 1000.0
+    # add more suffixes if you need them
+    if num % 1 == 0:
+        num = int(num)
+        return num + ['', 'K', 'M', 'G', 'T', 'P'][magnitude]
+
+    else:
+        return '%.2f%s' % (num, ['', 'K', 'M', 'G', 'T', 'P'][magnitude])

customeranalytics/web/app/__init__.py

@@ -0,0 +1,37 @@
+from flask import Flask
+from flask_login import LoginManager
+from flask_sqlalchemy import SQLAlchemy
+from importlib import import_module
+
+
+db = SQLAlchemy()
+login_manager = LoginManager()
+
+
+def register_extensions(app):
+    db.init_app(app)
+    login_manager.init_app(app)
+
+
+def register_blueprints(app):
+    for module_name in ('base', 'home'):
+        module = import_module('.{}.routes'.format(module_name), package=__name__)
+        app.register_blueprint(module.blueprint)
+
+
+def configure_database(app):
+    with app.app_context():
+        db.create_all()
+
+    @app.teardown_request
+    def shutdown_session(exception=None):
+        db.session.remove()
+
+
+def create_app(config):
+    app = Flask(__name__, static_folder='base/static')
+    app.config.from_object(config)
+    register_extensions(app)
+    register_blueprints(app)
+    configure_database(app)
+    return app

customeranalytics/web/app/base/__init__.py

@@ -0,0 +1,9 @@
+from flask import Blueprint
+
+blueprint = Blueprint(
+    'base_blueprint',
+    __name__,
+    url_prefix='',
+    template_folder='templates',
+    static_folder='static'
+)

customeranalytics/web/app/base/forms.py

@@ -0,0 +1,16 @@
+from flask_wtf import FlaskForm
+from wtforms import StringField, PasswordField
+from wtforms.validators import InputRequired, Email, DataRequired
+
+
+class LoginForm(FlaskForm):
+    username = StringField('Username', id='username_login', validators=[DataRequired()])
+    password = PasswordField('Password', id='pwd_login', validators=[DataRequired()])
+
+
+class CreateAccountForm(FlaskForm):
+    username = StringField('Username', id='username_create', validators=[DataRequired()])
+    email= StringField('Email', id='email_create', validators=[DataRequired(), Email()])
+    password = PasswordField('Password', id='pwd_create', validators=[DataRequired()])
+
+

customeranalytics/web/app/base/models.py

@@ -0,0 +1,43 @@
+from flask_login import UserMixin
+from sqlalchemy import Column, Integer, String
+
+try:
+    from sqlalchemy import Binary
+except:
+    from sqlalchemy import LargeBinary as Binary
+
+
+from .. import db, login_manager
+from .util import hash_pass
+
+
+class User(db.Model, UserMixin):
+    __tablename__ = 'User'
+    id = Column(Integer, primary_key=True)
+    username = Column(String, unique=True)
+    email = Column(String, unique=True)
+    password = Column(Binary)
+
+    def __init__(self, **kwargs):
+        for property, value in kwargs.items():
+            if hasattr(value, '__iter__') and not isinstance(value, str):
+                value = value[0]
+
+            if property == 'password':
+                value = hash_pass(value)
+            setattr(self, property, value)
+
+    def __repr__(self):
+        return str(self.username)
+
+
+@login_manager.user_loader
+def user_loader(id):
+    return User.query.filter_by(id=id).first()
+
+
+@login_manager.request_loader
+def request_loader(request):
+    username = request.form.get('username')
+    user = User.query.filter_by(username=username).first()
+    return user if user else None

customeranalytics/web/app/base/routes.py

@@ -0,0 +1,126 @@
+import logging
+from flask import jsonify, render_template, redirect, request, url_for
+from flask_login import (
+    current_user,
+    login_required,
+    login_user,
+    logout_user
+)
+
+from .. import db, login_manager
+from . import blueprint
+from .forms import LoginForm, CreateAccountForm
+from .models import User
+from customeranalytics.data_storage_configurations.logger import LogsBasicConfeger
+
+from .util import verify_pass
+
+
+LogsBasicConfeger()
+
+
+@blueprint.route('/')
+def route_default():
+    return redirect(url_for('base_blueprint.login'))
+
+
+@blueprint.route('/login', methods=['GET', 'POST'])
+def login():
+    login_form = LoginForm(request.form)
+    if 'login' in request.form:
+        
+        # read form data
+        username = request.form['username']
+        password = request.form['password']
+
+        # Locate user
+        user = User.query.filter_by(username=username).first()
+        
+        # Check the password
+        if user and verify_pass( password, user.password):
+
+            login_user(user)
+
+            return redirect(url_for('base_blueprint.route_default'))
+
+        # Something (user or pass) is not ok
+        return render_template('accounts/login.html', msg='Wrong user or password', form=login_form)
+
+    if not current_user.is_authenticated:
+        return render_template( 'accounts/login.html',
+                                form=login_form)
+    return redirect(url_for('home_blueprint.index'))
+
+
+@blueprint.route('/register', methods=['GET', 'POST'])
+def register():
+    login_form = LoginForm(request.form)
+    create_account_form = CreateAccountForm(request.form)
+    if 'register' in request.form:
+
+        username, email = request.form['username'], request.form['email']
+
+        # check username exists
+        user = User.query.filter_by(username=username).first()
+        if user:
+            return render_template('accounts/register.html',
+                                   msg='Username already registered',
+                                   success=False,
+                                   form=create_account_form)
+
+        # check email exists
+        user = User.query.filter_by(email=email).first()
+        if user:
+            return render_template('accounts/register.html',
+                                   msg='Email already registered',
+                                   success=False,
+                                   form=create_account_form)
+
+        # else we can create the user
+        user = User(**request.form)
+        db.session.add(user)
+        db.session.commit()
+
+        return render_template('accounts/register.html',
+                               msg='User created please <a href="/login">login</a>',
+                               success=True,
+                               form=create_account_form)
+
+    else:
+        return render_template('accounts/register.html', form=create_account_form)
+
+
+@blueprint.route('/logout')
+def logout():
+    logout_user()
+    return redirect(url_for('base_blueprint.login'))
+
+
+@blueprint.route('/shutdown')
+def shutdown():
+    func = request.environ.get('werkzeug.server.shutdown')
+    if func is None:
+        raise RuntimeError('Not running with the Werkzeug Server')
+    func()
+    return 'Server shutting down...'
+
+
+# errors
+@login_manager.unauthorized_handler
+def unauthorized_handler():
+    return render_template('page-403.html'), 403
+
+
+@blueprint.errorhandler(403)
+def access_forbidden(error):
+    return render_template('page-403.html'), 403
+
+
+@blueprint.errorhandler(404)
+def not_found_error(error):
+    return render_template('page-404.html'), 404
+
+
+@blueprint.errorhandler(500)
+def internal_error(error):
+    return render_template('page-500.html'), 500