DEV Community: billy_dev

Stealth Startups and the ethics of using Proxycurl.

billy_dev — Fri, 06 Jan 2023 09:22:40 +0000

What is a Stealth Startup?

A stealth startup is a startup company that operates in secrecy mode keeping it's true agenda private through various legal means, hence avoiding public attention and announcements about its products.

Reasons that may drive a Startup to operate in Stealth mode (Pros).

Ability to focus on product development without external pressure: A company can focus more on the product development process without facing product breakdowns or any extra financial crisis.

Opportunity to test the market without attracting competitors: By operating in secrecy, a company can be able to learn about the market need and also attain a deeper understanding of the market hence gaining an upper advantage among-st it's competitors.
Ability to delay costly marketing and branding efforts until the product is further developed: Stealthiness helps a company stay off the market hype thus reducing incurring unnecessary costs.
Opportunity to pivot or change direction without the scrutiny of the public: Due to less popularity stealth startups can observe trends from a "safe space" which gives them a clear overview of the market trends and customer demands which gives them the ability to steer their products or services to areas of profits.

While a company operating in stealth mode may seem to have more advantages compared to a public company, it is important to note that it also has some drawbacks. Needless to say, this is something to consider when starting a company.

Reasons to avoid going stealthy when building a startup company (Cons).

Difficulty in building a brand and reputation without a public presence: while trying to avoid the public eye a company may suffer in building its name thus losing a great deal in turning the public into potential customers.
Difficulty in securing funding without a public presence: this goes without saying a company may lose out to acquire funding and may get off to stunt growth.
Risk of losing potential customers or partners who may not be aware of the company's existence.: A company may lose out on loyal customers as they may lack trust in their products due to their lack of visibility.

The impact of Proxycurl on stealth startups.

Proxycurl is a platform that can help you get data about a company or people(employees) that is publicly available.
A Startup company may employ the use of Proxycurl peoples API to collect data about its employees' data and be able to spot top talent based on a person's data. And also track the movement of its employees' entrepreneurial talents by accessing their information about their employment status and professional experience.

Proxycurl can be used to collect data about a company about its financial acquisitions, and funding rounds which can be used to identify investment opportunities. you can explore Proxycurl and discover how it can help your company to expose Investment opportunities.

Lastly, by using the Proxycurl companies data set you can be able to identify Stealth companies by observing their history of funding data, and follower count. This data can help Investors be able to spot startups that haven't gone fully public yet and invest in them.

Summary

We looked a the concept of stealth startups, which are companies that operate in secrecy to avoid much public attention about their products. We talked about the good and the bad of such companies both on the company side and the customer part. Finally, we examined the impact Proxycurl could have on a stealth startup in its growth on financial aspect and the company growth.

Developing for the web with Flask; creating a web application.

billy_dev — Wed, 01 Sep 2021 15:09:17 +0000

Hey there, In this tutorial i will be showing you how to develop your first fullstack web-app project with flask-python.
In this tutorial or rather a documentation of how i did it, buckle up dev, and may the ride begin!

Prerequisites

Basic python language skills.
Basic command line commands.(linux)
PIP( a package manager for python) Installation allows you to install required libraries for a specific project, i.e: Flask
IDE(vscode, atom, sublime)
Python installed.

Launch
Installation
Templating
Conditionals
Looping
Web Forms
- Configurations
- Templating forms
Database
- Database migrations
- Database models
- Migrating Data to the DB
- Adding data to the database
Viewing Posts
Summary

Launch

Now setup up your project structure.
launch your code editor and create a directory in it.
mkdir blogger && cd blogger

Now create your starting files: mkdir app && cd app touch app.py routes.py models.py
While in the app directory create two directories mkdir templates static
Navigate to the root directory blogger and create the following files touch blog.py config.py all is set and your project structure should be looking like this:-

blogger/
|-app/
     |-templates #html files directory
     |-static #css& images directory
     |-__init__.py
     |-routes.py #site navigation capability
     |-models.py #db logic goes here
|-blog.py # main apprunning module
|-config.py

#tip: identation shows file location, eg; templates is in app dir

When working with external libraries it is good to run your project in a virtual environment, go ahead and install virtualenv via the terminal

pip install virtualenv
#create a virtual environment 
virtualenv bloggerenv
# you can name your env any name
# activating 
# windows
cd bloggerenv/Scripts/activate
# linux
source bloggerenv/bin/activate

#deactivating the env
deactivate

Installing libraries

We use the PIP to install the required libraries

(bloggerenv) $pip install Flask 
# this are the underlying packages to start a project

open the init.py in app directory type this:

#__init__.py
from flask import Flask
app = Flask(__name__) #flask object instance

from app import routes

first we import the Flask class from the flask module.
next we create the app object as an instance of the Flask class.
then import the routes module, to be created later

Open the routes.py file and we create the first route and test if everything is working.

from app import app

@app.route('/')
@app.route('/index')
def index():
  return "Hello, World!"

The first line imports the application instance.
This is a view function, what it does it returns the string Hello World, to the browser when the app is run.
The two first lines @app.route are called decorators, they create urls for the web-app.

Head over to the blog.py file and create the app running logic.

#blog.py
from app import app

if __name__ == '__main__:
    app.run()

With this our app is done and can be previewed in the browser.But before running Flask needs to be told how to import it, through the FLASK_APP environment.

(bloggerenv) $ export FLASK_APP=blog.py

If you are using a windows OS use the keyword set instead of export.
You can run your app in the terminal now:

(bloggerenv) $ flask run
 * Serving Flask app 'blog.py' (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: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Copy the url http://127.0.0.1:5000/ in the browser.

Voila! app running and good.

Templating

In this section i'll show how to work with templates to generate more elaborate web pages with more complex structures.
We are going to use Jinja2, it is a templating engine for
flask.
We are going to store the template/html files in the templates folder.
Create an index.html file and open it.

app/
    |-templates/ 
               |-index.html

I want the homepage to display a custom welcome message to the user
In the routes file create a python dictionary that holds our mock user:

from flask import render_template
from app import app

@app.route('/')
@app.route('/index')
def index():
    user = {'username' : 'Developer'}
    return render_template('index.html', title='Home', user=user)

Here we import the render_template function from the flask module. It handles html rendering in python
Then we create mock data as a python dictionary for a user, this will change henceforth as we include a database.

Let's code the index.html file:-

<!doctype html>
<html>
    <head>
        <title>{{ title }} - blogger</title>
    </head>
    <body>
        <h1>Hello, {{ user.username }}!</h1>
    </body>
</html>

When we run this version of the app, we get a nice preview with the username printed out.
substitutes {{ ... }} blocks with corresponding values, given by the arguments provided in the render_template() call.

Conditional statements in jinja2

Jinja2 supports control statements given inside {%..%}
Add a conditional statement to the index.html that will print the documents title when provided in the render_template() call and prints out a default title if None is provided.
Put this block in the <head> section:

{% if title %}
  <title>{{ title }}</title>
{% else %}
  <title>App | blogger</title>
{% endif %}

Loops

And yes jinja2 also supports looping, what did you expect!😂
lets add a mock data in our routes.py file for posts

from flask import render_template
from app import app

@app.route('/')
@app.route('/index')
def index():
    user = {'username' : 'Developer'}
    posts =[
        {
        'author': {'username': 'Guido'},
        'body': 'I designed python language'
        },
        {
         'author': {'username': 'Jack'},
        'body': 'Blue is a cool color'
        }
    ]
    return render_template('index.html', title='Homer', user=user, posts=posts)

I create a list posts with nested dictionaries, where each element is a dictionary that has author & body fields.

Now head on to index.html and handle the rendering of posts in the browser, posts can be of any number and we need to tell the temlate how to render them all, for that case we use a for loop.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{ title }} - blogger</title> 
</head>
<body>
    {% if user.username %}
        <p>Hello, {{ user.username }}</p>
    {% else %}
        <p>Hello, World!</p>
    {% endif %}

    <h2>My posts!</h2>
    {% for post in posts %}
        <b>{{ post.author.username }}</b>
        <p>{{ post.body }}</p>
    {% endfor %}
</body>
</html>

Give this new version a try and voila!!🤯🤯

When the structure of the app gets bigger and bigger we need to separate some preferences, for example, when linking css files or having a navbar in our website, its needed anyway.😊 we ought to do it in a separate template file.
We call this template inheritance:-

Go ahead and create; base.html in the templates directory.

<!-- base.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
    {% block title %} 
        <title>Document</title>
    {% endblock %}
</head>
<body>
    {% block content %}

    {% endblock %}
</body>
</html>

With this we can now simplify our index.html file:-
to inherit a template file we use the {% extends %} tag, at the top of the child template.

{% extends 'base.html' %}
{% block title %}
    {% if user.username %}
        <title>{{ title }}- blogger</title>
    {% else %}
        <p>Blogger</p>
    {% endif %}
{% endblock %}
{% block content %}
    <h2>My posts!</h2>
    {% for post in posts %}
        <b>{{ post.author.username }}</b>
        <p>{{ post.body }}</p>
    {% endfor %}
{% endblock %}

Template inheritance allows us to have the same look in every page without duplication.
Hence enabling us to be 'DRY'.
If you go and run this the results will be the same as above.

As the application growsn it will require more functionality and features; like web forms, etc.

Web forms.

In this chapter I'll show you how to create web forms to take user input via the browser.
We use an extension called Flask-WTF, it is a wrapper found in the package WTForms, that integrates well with Flask.

(bloggerenv) $ pip install flask-wtf

Configurations

For tutorial purposes I am going to create just a simple form.
But before that, I am going to set some configuration variables, for separation of concerns i am going to define my app configs in the config.py module in the top most directory.
I'll use a class to store any config variables and new configuration variables can be added here.

# config.py
import os

class Config(object):
    SECRET_KEY = os.environ.get('SECRET_KEY') or 'you-will-never-guess'

the SECRET_KEY configuration variable is an important config in most flask apps, it is used by the Flask-WTF to protect web forms against the Cross Site Request Forgery(CSRF) attack.
The value of the secret key is set as an expression with two terms, joined by the or operator. The first term looks for the value of an environment variable, also called SECRET_KEY. The second term, is just a hardcoded string.
For now the app is small and doesn't require much security, i'll just use the hardcoded string, but when deploying it needs to be replaced with a unique key, can be generated in the python shell using the urandom module

>>>from os import urandom
>>>urandom(20)
b'\x1d\x00\x08\x8b \xd8\xae\xe9....

Now that i have the config set up, i have to tell Flask to read and apply it. This can be done right after the flask app instance in the __init__.py using the app.config.from_object() method:.

from flask import Flask
from config import Config

app = Flask(__name__)
app.config.from_object(Config)

from app import routes

Creating the first form, once again having the separation of concerns in mind, in the app directory create a file forms.py
The Flask-WTF extension uses Python classes to represent web forms. A form class simply defines the fields of the form as class variables.

#app/forms.py
from flask_wtf import FlaskForm
from wtforms import StringField, TextAreaField, SubmitField
from wtforms.validators import DataRequired

class PostForm(FlaskForm):
    username = StringField('User name', validators=[DataRequired()])
    post = TextAreaField('Post', validators=[DataRequired()])
    submit = SubmitField('Submit')

Import the FlaskForm base class.
For each form you will need you create a separate class variable, each field is given a label as the first argument.
The validators field is used to attach validation behaviors to form fields. -The DataRequired validator checks that a field is not submitted empty.

Form Templates

Next is to add the form to a HTML template, so it gets rendered to the web page.
The LoginForm class knows how to render itself as HTML, this makes the next part fairly simple.

create a file new_post.html in app/template/new_post.html N/B:For uniformity inherit the base.html template inside the new template.

{% extends 'base.html' %}
{% block title %}
    {% if title %}
        <title>{{ title }}- blogger</title>
    {% else %}
        <p>Blogger</p>
    {% endif %}
{% endblock %}
{% block content %}
    <form action="" method="POST" novalidate>
        {{ form.hidden_tag() }}
        <p>
            {{ form.username.label }} <br>
            {{ form.username(size=32) }}
        </p>
        <p>
            {{ form.post.label }} <br>
            {{ form.post(size=120) }}
        </p>
        <p>
            {{ form.submit() }}
        </p>
    </form>
{% endblock %}

This template expects a form object be instantiated in the PostForm class to be given as an argument.Which is referenced as form, the argument will be sent by the post view function.

the html <form> element is used as the container for the web form.
the action attribute tells the browser the url to use when the form data is submitted. when set to an empty string the form is submitted to the current URL in the browser.
The method attribute specifies the HTTP request method to be used when submitting the form to the server.
novalidate tells the browser not to validate the forms as that is the work of Flask application running in the server.
The form.hidden_tag() template argument generates a hidden field that includes a token that is used to protect the form against CSRF attacks.
The {{ form.<field_name>.label }} replaces the label element, and the {{ form.<field_name>() }} goes where the form field is needed. Read more on the jinja2 documentation.

Form view function.

In order to render the Form to the web page a route functionality is needed, In the routes.py module add the following view function at the end.

#....

# route to the post form
@app.route('/post')
def post():
    form = PostForm()
    return render_template('new_post.html', title='Add post', form=form)

Here i imported the PostForm class from forms.py, instantiated an object form = PostForm() from it and sent the object down to the template form=form.
The form=form parses the form object to the template form, it is what's required to render the form fields.

When you run the app and navigate to http://127.0.0.1:5000/post a html form is displayed. But when you try to submit it a method not allowed is thrown. I'll fix that in a minute.

Next I'm going to create the navigation links inside the base.html file.

<!-- .... -->
<body>
    <div>
        <b>Blogger:</b>
        <a href="{{ url_for('index') }}">Home</a>
        <a href="{{ url_for('post') }}">Add Post</a>
    </div>
    <hr>
<!-- .... -->

Add the above block just below the body tag, when the app is run we get a simple navbar at the top. That actually works 😉.

As you noticed when i created the navbar links i used a different method, the url_for() function from Flask. which generates URLs using iternal mapping of urls to view functions.Read ahead and practice working with forms.

Remember when you tried running the app and an error came shouting, that was because the post view function didn't understand what to do.
To fix it we add the methods=['POST', 'GET'] in the route decorator.
The new updated route should look like this

# route to the post form
from flask import Flask, redirect, flash
@app.route('/post', methods=['POST', 'GET'])
def post():
    form = PostForm()
    if form.validate_on_submit():
        print(f"Hey, {form.username.data}! Your post '{form.post.data}'  was successfully submitted! ")
        return redirect('/index')
    return render_template('new_post.html', title='Add post', form=form)

Here we use an if statement to validate the form data in the view function.
The validated_on_submit() runs validation of a form, Call validate only if the form is submitted. This is a shortcut for form.is_submitted() and form.validate().
Here I use the print() function to print a custom message in the terminal, later I will be using the Flask flash() function to flash messages in the web page.
redirect: this function redirects to a specified url.
flash: it flashes a message to the web page after an action has been carried.

Database.

Flask doesn't support databases natively, it isn't opinionated in this field, so it gives you the freedom to choose across a variety of database options that best fits your application.

Databases can be separated into two, those that follow relational models and those that do not. referred as NoSQL dbs.

We are going to use Flask-sqlalchemy, an extension that provides a Flask-friendly wrapper to the popular SQLAlchemy package, SQLAlchemy is an ORMObject Relational Mapper.
An ORM allows applications to manage databases using high level entities such as classes, objects & methods instead of tables and SQL. The work of an ORM is to convert high-level operations into database commands.
Installing flask-sqlalchemy run this in the terminal.
(blogger) $ pip install flask-sqlalchemy

Database Migrations

As the application continues to grow, it might need changes or updates, also the database needs be updated. This is done through migrations and the flask extension that handles this is : Flask-migrate.
This extension is a Flask wrapper for Alembic a flask database migration framework for SQLAlchemy. Install the extension;
(blogger) $ pip install flask-migrate

Flask-SQLalchemy configuration

In the development phase I will be using SQLite database. It saves each database file on disk.
When the app reaches production, I will use a database server: PostgreSQL or MySQL.
Two configurations are required in the config.py module:

import os
basedir = os.path.abspath(os.path.dirname(__file__))

class Config(object):
    SECRET_KEY = os.environ.get('SECRET_KEY') or 'you-will-never-guess'
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or 'sqlite:///' + os.path.join(basedir, 'app.db')
    SQLALCHEMY_TRACK_MODIFICATIONS = False

The Flask extension gets the location of the apps database from the SQLALCHEMY_DATABASE_URI configuration variable.

As I did with the SECRET_KEY variable fallback, I also provide a fallback value if the config variable doesn't define the database url.
The SQLALCHEMY_TRACK_MODIFICATIONS configuration if set to False disables a Flask-SQLAlchemy feature that sends a signal to the application every time a change is about to be made to the database.

The database is represented in the application by a database instance. This is done in the app/__init__.py file.

from flask import Flask
from config import Config
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate

app = Flask(__name__)
app.config.from_object(Config) #configuration 
db = SQLAlchemy(app) #database instance
migrate = Migrate(app, db)

from app import routes, models

In this change of the init file, I imported two new extensions: SQLAlchemy & flask_migrate.
I have added a db object, it represents the database.
The migrate variable handles the migration engine.
At the bottom I've imported a new module models , This module defines the structure of the database.

Database models.

Data stored in the database will be represented by a collection of classes, usually known as database models. The ORM layer will handle the translastions required for mapping objects created from this classes to the correct rows in the database tables.
Let's create a database model, create a new file app/models.py

from app import db

class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(32), index=True, unique=True)
    post = db.Column(db.String(120), index=True)

    def __repr__(self):
        return(f"<User>: {self.username}, <Post>: {self.post}")

The id field is usually in all models, and is used as the primary key. Each user is assigned a new id and is stored in this field.
The username & post field are defined as strings(in database is known as VARCHAR) and their maximum lengths specified.
The Post class created above inherits from db.Model, a base class for all models from Flask-SQLAlchemy.
Fields are created as instances of the db.Column class, whih takes field type as arguments.
The __repr__ tells python how to print objects of this class. It is useful for debugging. Open python in a terminal try to assign some data to our class objects.

(blogger) $ python
>>> from app import db
>>> from app.models import Post
>>> p = Post(username="John", post="Hello, World!")
>>> p
<User>: John, <Post>: Hello, World!
>>>

The model created above defines the initial database structure or schema of this application.

Create a migration repository.

When the app continues to grow, we need to handle the changes such as adding new things, modifying or removing items.

The Alembic extension takes care of this schema changes. It maintains the migration repository, a directory in which it stores the migration scripts.
Each a change is made to the database schema, a migration script is added to the repository with the details of the change.
To apply the migrations to a database, these migration scripts are executed in the sequence they were created.
The flask db sub-command is added by flask-migrate to manage everything related to database migrations.
To create a migration repository :

(blogger) $ flask db init
Creating directory E:\code\projects\blogger\migrations ...  done
Creating directory E:\code\projects\blogger\migrations\versions ...  done
Generating E:\code\projects\blogger\migrations\alembic.ini ...  done
Generating E:\code\projects\blogger\migrations\env.py ...  done
Generating E:\code\projects\blogger\migrations\README ...  done
Generating E:\code\projects\blogger\migrations\script.py.mako ...  done
Please edit configuration/connection/logging settings in 'E:\\code\\projects\\blogger\\migrations\\alembic.ini' before proceeding.

The flask command relies on the FLASK_APP environment variable, after a successful run a new migrations directory is added.
Now we need to create our fist database migration.

(blogger) $ flask db migrate -m 'posts table'
INFO  [alembic.runtime.migration] Context impl SQLiteImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
INFO  [alembic.autogenerate.compare] Detected added table 'post'
INFO  [alembic.autogenerate.compare] Detected added index 'ix_post_post' on '['post']'
INFO  [alembic.autogenerate.compare] Detected added index 'ix_post_username' on '['username']'
Generating E:\code\projects\blogger\migrations\versions\549b927398fe_posts_table.py ...  done

After running this, no change has been made to the database it just generates a migration script. Now we need to make changes to the database, To do that we use a flask sub-command flask db upgrade in the python shell context.

$ flask db upgrade
INFO  [alembic.runtime.migration] Context impl SQLiteImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
INFO  [alembic.runtime.migration] Running upgrade  -> 549b927398fe, posts table

At this point you can play with the database a little, Let's try to add the previous post to the database.

The db changes are done in a database session context.
To add data to the db we use db.session.add(p), p is the object created for the corresponding database table.
To write the changes use: db.session.commit().

(blogger) $ python
>>> from app import db
>>> from app.models import Post
>>> p = Post(username="John", post="Hello, World!")
>>> p
<User>: John, <Post>: Hello, World!
>>> db.session.add(p)
>>> db.session.commit()
>>> Post.query.all()
[<User>: Ariana, <Post>: Testing 2, <User>: John, <Post>: Hello, World!]
>>>

first import the database object from the app module
Import the Post class from the models module.
Create a Post object name it p.
use the db session context to add and push the change to the db.
The last command Post.query.all() answers queries and returns all posts in the database.

Adding data to the database

When a user types their data in the forms, and hits submit button the form data needs to be written in the database.
To do that I shall add the db session commands in the view function /post.
Your new changed app/routes.py should look like this.

# route to the post form
@app.route('/post', methods=['POST', 'GET'])
def post():
    form = PostForm()
    if form.validate_on_submit():
        add = Post(username=form.username.data, post=form.post.data)
        db.session.add(add)
        db.session.commit() 
        flash(f"Hey, {form.username.data}! Your post '{form.post.data}'  was successfully submitted! ")
        return redirect('/index') 
    return render_template('new_post.html', title='Add post', form=form)

Now when a user enters data in the web forms and hits submit the data gets written to the database, we can view the data in a browser.

Viewing Posts in the Web-page

This part is rather simple, I just need to create a template that renders the posts in the database I will just use a for loop to loop through the available posts in the database.

Head over to the IDE and create a new template file, name it whatever you prefer. app/templates/all_posts.html

{% extends 'base.html' %}
{% block title %}
    {% if title %}
        <title>{{ title }}- blogger</title>
    {% else %}
    <p>Blogger</p>
        {% endif %}
{% endblock %}

{% block content %} 
    <h2>Published Posts.</h2>
    {% for post in posts %}
        <b>{{ post.username }}</b>
        <p>{{ post.post }}</p>
    {% endfor %}
{% endblock %}

When you run the application and navigate to http://127.0.0.1:5000/view all our posts are displayed in the web-page.

Now we can head and add a nav link for viewing all our posts, this is will be added in the base.html file:

<a href="{{ url_for('view') }}">Posts</a>

Add this line of code in the div inside the base template file. Preview the app in the browser and a new a navbar link has been added.

Summary

In this article I took you through working with flask to create a minimal web application that takes user input via a web form and saves it in a database and retrieves it and displays it in a web-page.

I worked you on using the Flask-SQLAlchemy and integrating a flask app with a database.
Creating a database and managing the database modifications.
Templating and rendering web-pages. Go ahead and play with the UI by changing the style.css inside the app/static directory

body {
    background-color: #7fffd4;
}

When I add a the background color property the web page color changed, I shall write more on this in another article.

Thank you for taking your time to go through this article, Any feedback, advice or help is appreciated. Drop me a comment for any issue with running the code or improvement suggestions ;-)

In the next article i'll cover on deploying this flask app to heroku.
References: [https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world]

The whole code is available on Github, go ahead and star the repo or clone it for your practice.

Thank you @grayhat and Lux Tech Academy.

Be cool and Keep coding! mic drop...dev out

Web development using Python.

billy_dev — Wed, 11 Aug 2021 18:27:49 +0000

Definition
Introduction
Summary

Definition

You can develop for the web using Django, fast-api && flask
Flask is a Python web-framework, it is a third party library used for web development.
Flask focuses on step-by-step web development.
It is light weight micro-web framework based on two libraries werkzeug WSGI toolkit && Jinja2 templates

Setting up Flask

Before installation of flask, make sure you are in your virtual environment.

pip install virualenv
#activating:Linux
env/bin/activate
#windows
cd env\Scripts\activate

When you are in your virtual env run:

pip install flask
# or
pip3 install flask

Introduction

All things set👍! now we create a hello world app.✨

# import Flask class
from flask import Flask
#instantiate flask app obj
app = Flask(__name__)

# decorator function(routing)
@app.route('/')
def index():
    return 'Hello world!'


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

Go ahead and type this in a text editor save as app.py
The condition checks if the code is a flask app .

if __name__ == '__main__':
    app.run()

Running a flask app.

type the following commands in terminal

#first we set the flask_app variable 
# Linux
export FLASK_APP=app.run
#window
set FLASK_APP=app.run
# run it
flask run

Yaaay! 🎉 our hello world is live and running on: http://127.0.0.1:5000

Creating a route

A route is a URL to a location in the browser.
Routes are created with the route() decorator, they handle requests for the flask app.

@app.route('/')
def index():
    return 'Hello world!'

This opens the home page in our app.

Rendering HTML from flask

To render html flask uses Jinja2 templating engine.

from flask import Flask, render_template

@app.route('/about')
def about():
    return render_template('about.html')

Variable rules in Flask.

Variables create a dynamic URL route for a flask app, a variable section is marked with angle brackets <variable_name>.
The function receives the variable as a keyword argument, Optionally you can specify a converter for a variable <converter:variable_name>

@app.route('/age/<int:num>')
def age(num):
    return f'<p>This Blog is {num} old.</p>'

Summary

In this article we have gone through web development with Flask a python web-framework.

Installation
Hello world application.
Dynamic URLS.

In the next article, I'll write on connecting Flask to a database.

Thank you for reading, I'd really love your feedback or guidance.
Be cool, Keep coding!

Python Basics 102: Introduction to Python Functions.

billy_dev — Sat, 31 Jul 2021 17:27:33 +0000

Hello world, In the previous post i introduced you to Python programming language, a high level language.
In this second post I am going to be taking you through python Functions.

Python Functions

~~everything we do comprises of a function somewhere.~~
So, what are functions in python!

A function is a block of code that has statements that perform a specified task.
They help in breaking down a program when it grows big.
Functions minimize the repetition of code, hence they're reusable.

Let us define a function:
We use the def keyword to define a function:

# define a function that says Hi.
def greet():
    print("Hello")

#calling the function
greet()
#prints> Hello

🤯 Awesome!

# structure of a function
def function_name(paramters):
    """docstring"""
    statement(s)

A python function consists of the following:

the def keyword, marks the beginning of a function
A function name to identify the purpose of the function, Function names follow the same guide rules of pep8 naming conventions.
parameters to which values to our functions.
A colon (:) to mark the end of a function definition.
In the body start with a """docstring""", to explain what the function does.
One or more valid python statements that make up the function body.
The return(optional) statement that returns a value to the function.

Python Function Arguments

Functions takes variables as arguments.
Ways of defining arguments; using default, keyword and arbitrary arguments.
Defining functions with parameters. Parameters are identifiers in the function definition parentheses

#function parameters
def greet(name, msg):
  print(f"Hello {name}, {msg}")

#call the function with the arguments
greet('Mark', 'Good Evening')
#prints> Hello Mark Good Evening

Here, the function greet() has two parameters name, msg
When the function is called, the two parameters are passed as arguments.

Variable Function Arguments

A function can take a variable number of arguments.

Function Default Arguments

def greetings(name, msg="How are you?"):
    print(f"Hello, {name} {msg}")

#positional arguments.
greetings('Asha')
#> Hello, Asha How are you?

Even if we call the function with just one argument, it will complete smoothly without an error unlike in the previous function.
When an argument for msg is provided in function call, it will overwrite the default argument.

Python Keyword Arguments

When a function is called with values, they get assigned to their specific positions.
But this can be changed when calling a function, the order can be altered with keywords, like in the above function we could call it like this:

#keyword arguments in order
greetings(name="fast furious", msg="is out!")

#keyword arguments out of order
greetings(msg="is out!", name="Vin")

Well give it a try, everythings works just fine.

Python Arbitrary Arguments

At times you might not know the number of arguments to be passed in a function.
In situations like this, python allows the use of an asterisk (*) to denote arguments. example:

def greet(*names):

   for name in names:
       print(f"Hello {name}.")

greet('juma', 'larry', 'lilian')
#> Hello juma.
#> Hello larry.
#> Hello lilian.

Python Recursion

Recusion with python functions.
A repeated procedure can be reffered to as a Recursion.
A recursive function, is a function that calls itself.

def recurse():
    #statements
    recurse() #recursive call

recurse()

An example:

#finding the factorial of a number
def factor(x):
  """
  this function finds the factorial of a given number
  factorial number is the product of a 
  number starting from 1 to that number itself
  """
  if x == 1:
    return 1
  else:
    return (x * factor(x-1))


num = 3
print(f"factorial is:  {factor(num)}")

Pros of Recursion Functions

Makes code look clean and elegant.
Breakdown of complex tasks into smaller sub-tasks.
Sequencing is easier compared to nested iteration.

Cons

They are difficult to debug.
Recursive calls take alot of memory and time.
Hard to read or follow.

Anonymous Functions

An anonymous function is a function that has no name.
They are also called lambda functions.
Defining a lambda function:

#syntax:
lambda arguments: expression

They can have multiple arguments but only one expression.
working example:

#sum of numbers
sum = lambda x: x+2
print(sum(2))
#> 2+2= 4

#multiple args
product = lambda x, y: x*y
print(product(2, 6))
#> 2*6 = 12

Lambda functions are used when a nameless function is required for a short period of time.
They are best used with in-built functions, filter() & map().Read more

That's it for now, Hope you enjoyed reading this article.
let us learn python!!
Be cool, Keep coding.

Python basics 101

billy_dev — Fri, 23 Jul 2021 17:02:27 +0000

What is python?

Python is a high-level, general-purpose and a very popular programming language. It was created by Guido van Rossum and first released in 1991. Python is dynamically and strongly typed.

Python pros

simplicity: high-level programming language has easy syntax. Makes it easier to read and understand the code.
Portability: Write once and run it anywhere.
Free and Open-Source: This makes it free to use and distribute. You can download the source code, modify it and even distribute your version of Python.
Dynamically Typed: Python doesn’t know the type of variable until we run the code.Data types are asssigned at execution

Setup and Running

It can be used across all platforms i.e: Windows, Linux, Mac OS.
Windows: Download python for windows
Linux: Linux systems are pre-installed with python 2.
to upgrade to py3 use below commands;
$ sudo apt-get update $ sudo apt-get install python3.6

Running python code

After correct setup run command prompt in windows or terminal for linux and type python:
C:users\dev> python Python 3.8.10 (tags/v3.8.10:3d8993a, May 3 2021, 11:48:03) [MSC v.1928 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "license()" for more information.

>>>print("Hello World!")
>>>Hello World! #this a comment

Voila! You run your first python code in command line. The print() method is used to display on the screen.
python programs are saved with a .py extension, i.e hello.py.

To execute a program navigate to its path using cmd or terminal in linux/mac os; run this

$ python3 hello.py
$ Hello World! #gets printed if all is okay
#creating a comment is done with '#' or """..."""

python applications in real world.

Python is the “most powerful language you can still read”.
– Paul Dubois

Variables in python

Python variables are containers for storing data values.

#assigning variables
name = "billy" #type(name)>'str'
age = 23 #type(age) is> 'int'

variable names are called identifiers, and they follow some naming conventions as guided by pep8.

Variables can have letters (A-Z and a-z), digits(0-9) and underscores.
It cannot begin with an underscore (_) or a digit.
It cannot have whitespace and signs like + and -, !, @, $, #, %.
It cannot be a reserved keyword for Python like: False, True, for, def, etc.
Variable names are case sensitive.

#valid variable names:
name1
age
second_name
age_2
PythonProjects

#invalid names
1name
for
email@com

Operators

Python has 7 types of operators. Operators will ease your programming pains.
Operator are symbols that perform mathematical operations on variables or on values.

Arithmetic Operators
+ addition, - subtraction, * multiplication, / division, ** exponentiation, // floor, % modulus
Relational operators
> greater than, < less than, == equality checker, <= less than/equal to, >= greater than/equal to, != not equal to
Assignment operators
= assign, += add & assign, -= subtract & assign, *= multiply & assign, / divide & assign, **= exponentiation & assign, //= floor & assign % modulus & assign
Logical operators
or- logical or, and- logical and, not logical not
Membership operators
in, & not in
Identity operators
is && is not
Bitwise operators
They operate on values bit by bit.
& Bitwise and, | Bitwise or, ^ Bitwise xor, ~ Bitwise 1’s complement, << Bitwise left shift, >> Bitwise right shift

Python Number data types

Python has three numeric data types: int, float, & complex.

int: an integer is a whole number that can be either positive or negative.

num = 100
code = -3255522
long = 35656222554887711 #can be of unlimited length

float: "floating point number" is a number, positive or negative, containing one or more decimals.

num2 = 10.2
year = 12E4 #can also be scientific numbers with an "e" 
#to indicate the power of 10.
zeus = -35.59

complex: Complex numbers are written with a "j" as the imaginary part.

x = 3+5j
y = 5j
z = -5j

Type conversion

You can convert one data type to another using built-in methods.

#int(), float(), complex()
c = 1
b = 1.23
a = 5j
float(c) #is 1.0
int(b) #is 1
complex(c) #is 1+0j

Strings

Strings are sequences of characters and are immutable.
they are enclosed in 'single quotes' or "double quotes".

'this is a str'
"also this"
"""and this too"""

You cannot start a string with a single quote and end it with a double quote (and vice versa).

'post\'s are personal'
#use a backslash to escape quotes inside the str 
#if the match the enclosing ones.

be sure to checkout more on strings for more info.

Python Data Structures

Python data structures store collections of values. they are:

Lists
Tuples
Sets and frozensets
Dictionaries
Strings

Lists

Lists are ordered items and are mutable, means can be changed.
Lists hold any type of data type.
Tip: counting/indexing in python starts at 0

#indexing 
l|i|s|t
0|1|2|3
#######
myList = [1, 'python', ['a nested List']] #defining a List
#List methods
myList[0] #prints 1
myList.append('name') #adds 'name' at the end of the list
len(myList) # prints 3, we appended 'name' ;)

Tuples

Tuples are collections of Python objects.
Tuples are similar to lists, but are immutable, cannot be changed.
Note: To create a single item tuple, you have to use a comma after the value. num = (5,)

#creating tuples
fruits = ('mango', 'apple', 'kiwi')
print(fruits[1]) #'apple'
#looping
for x in fruits:
  print(x)

Dictionaries

Dictionaries in Python are collections that are unordered, indexed and mutable.
They hold keys and values. Are just like real life dictionaries, consisting of words and their meanings.
Python dicts consist of key, value pairs.
This is a dictionaries:

animals={'dog': 'mammal', 'cat': 'mammal', 'snake': 'reptile', }

#indexing, can be accessed using keys
animals #prints 'dog': 'mammal', 'cat': 'mammal', 'snake': 'reptile'
animals['cat'] # 'mammal'

#get() method gets specified key
animals.get('dog') #'mammal'

#adding items
animals['frog'] = 'amphibian' #pushes frog to end of dict

#pop() removes specified item
pop('cat') #'mammal' removed and returned

#del keyword to delete dictionary items.
del animals['dog'] 

#clear() removes all the key values pairs from the dict
animals.clear() # {}

#changing values
animals['cat'] = 'just a cat'

Sets

Sets in Python are a collection of unordered and unindexed Python objects.
Sets are mutable, iterable and they do not contain duplicate values.

#creating a set
tickets = {1, 2, 3, 4, 5}
items = {99, 100, 200, “yes”, “no”}

#creating empty sets
empty_set = set()
print(empty_set)

#accessing sets
a = {7, 6, 5, 4, 3, 4, 5, 6}
print(a)
#>> {3, 4, 5, 6} #sets do not contain duplicate values

#deleting in sets
# discard(), remove(), pop() and clear().
a = {1, 2, 3, 4}
a.discard(3) # {1,2,4} remove() is similar do discard

#pop() 
print(a.pop()) #> 4

#clear()
print(a.clear()) #> {}

There is more to sets than just this.

Conditionals or Decision making

Python decision making.
Decisions are useful when you have conditions to execute after a certain action, like a game, or checking for even numbers etc.
Python has got you, we use if, if-else, if-elif, & nested conditions in situations like this.

#python if statement
num = 3
if(num % 2 == 0):
  print('Even')
print('Odd')

#if-else statement
if(expression):
  statement
else:
  statement
#example
if(12 % 2 == 0):
  print('Even')
else:
  print('Odd')

#if-elif
if( expression1 ):
  statement
elif (expression2 ) :
  statement
elif(expression3 ):
  statement
else:
  statement

You will encounter conditions everywhere throughout your coding journey. Be sure to read more.

Loops

Now we checkout python loops.
Loops are one of the most powerful and basic concepts in programming.
A loop can contain a set of statements that keeps on executing until a specific condition is reached.
Python has two types of loops: for loop & while loop

for loop

Used to items like list, tuple, set, dictionary, string or any other iterable objects.

for item in sequence:
    body of for loop

for loop continues until the end is reached.

while loop

It executes a block of code until the specified condition becomes False.

counter = 0
while(counter < 10):
  print(counter)
  counter = counter +1
#prints 1-10

Controlling the flow with:

python lets you control the flow of execution in a certain way
pass
break statement inside a loop is used to exit out of the loop.
continue statement is used to skip the next statements in the loop.

Loops are bit extensive than just this but i believe this guide gave you an idea of what python is.

That's it for now. Bless.
Be cool, Keep coding.

Re-app back onto python.

billy_dev — Tue, 20 Jul 2021 10:35:50 +0000

name = input("type your name here: ")

print(f"Hello Dev {name}!")

DEV Community: billy_dev

Stealth Startups and the ethics of using Proxycurl.

What is a Stealth Startup?

Reasons that may drive a Startup to operate in Stealth mode (Pros).

Reasons to avoid going stealthy when building a startup company (Cons).

The impact of Proxycurl on stealth startups.

Summary

Developing for the web with Flask; creating a web application.

Prerequisites

Contents

Launch

Installing libraries

Templating

Conditional statements in jinja2

Loops

Web forms.

Configurations

Form Templates

Form view function.

Database.

Database Migrations

Flask-SQLalchemy configuration

Database models.

Create a migration repository.

Adding data to the database

Viewing Posts in the Web-page

Summary

Web development using Python.

Contents

Definition

Setting up Flask

Introduction

Running a flask app.

Creating a route

Rendering HTML from flask

Variable rules in Flask.

Summary

Python Basics 102: Introduction to Python Functions.

Python Functions

Python Function Arguments

Variable Function Arguments

Python Keyword Arguments

Python Arbitrary Arguments

Python Recursion

Pros of Recursion Functions

Cons

Anonymous Functions

Python basics 101

What is python?

Python pros

Setup and Running

Running python code

python applications in real world.

Variables in python

Operators

Python Number data types

Type conversion

Strings

Python Data Structures

Lists

Tuples

Dictionaries

Sets

Conditionals or Decision making

Loops

for loop

while loop

Controlling the flow with:

Re-app back onto python.