History of Speech-to-Text Models​ & Current Infrastructure

As speech technology continues to advance, so too do the models that power it. From early traditional algorithms to modern machine learning models, the field has come a long way in a relatively short amount of time. Especially today, we are experiencing breakthroughs and paradigm shifts with the rise of neural networks and applications based on the Transformer architecture.

In this article, we will take a deep dive into the history of AI models in speech-to-text and explore how these models have evolved over time, bringing us closer to achieving human-level accuracy in this critical technology. Additionally we will briefly cover the current infrastructures that redefine almost all industries through innovative implementation of AI models on computational cloud services.

Contents

1. History of Speech-to-Text Models
   • Pre-2000
   • Early Millenia
   • Post 2015
     • 2015
     • 2017
     • 2019
     • 2020
     • 2021
     • 2022
     • 2023
2. Speech-To-Text on Cloud
   • Pros Cons of Speech-to-text Cloud Services

Summary

History of Speech-to-Text Models

We can see several scientific and technological milestones as well as accelerated innovation in the short history of speech-to-text models since 1950s. We’ll take a closer look at the exciting developments that occurred in this field throughout the decades.

Pre-2000

The history of speech-to-text (STT) dates back to the early 1950s, when researchers first began to explore the use of computers to recognize speech. Here is a brief timeline of some of the key developments in the history of STT:

1952:

Researchers at Bell Laboratories developed the “Audrey” system, which could recognize single-digit spoken numbers.

1960s:

The advent of digital signal processing (DSP) and the development of algorithms for pattern recognition led to significant progress in speech recognition research.

1970s:

The “Hidden Markov Model” (HMM) was developed, which became a popular approach for speech recognition. HMMs use statistical models to represent the probability of speech sounds and transitions between them. “Markov Models for Pattern Recognition: From Theory to Applications” by Lawrence R. Rabiner, published in 1989 was particularly influential. In this paper, Rabiner described the use of Hidden Markov Models (HMMs) for automatic speech recognition (ASR), which revolutionized the field of speech recognition and has remained a cornerstone approach ever since. His work contributed significantly to the development of practical ASR systems that were accurate and efficient, and paved the way for future research in this area. Here is a technical tutorial on HMM and Selected Applications in Speech Recognition.

1980s: The “Dynamic Time Warping” algorithm was developed, which could recognize speech in noisy environments. Professor Romain Tavenard from Université Rennes 2 has a great article regarding Dynamic Time Warping and its algorithmic foundation. Professor Tavenard also has an open source Dynamic Time Warping repo where source code for applications of tslearn (time series machine learning) with Python can be found along with many other interesting repositories such as K-means clustering demonstrations. Tslearn is a go-to Python library for implementing DTW with time series.

1990s: The development of neural networks and machine learning algorithms led to significant progress in speech recognition. Large vocabulary speech recognition systems also became more widely available.

OpenAI models are quite the hot topic right now. OpenAI has a very useful API structure which you can access with Python and leverage this edge-cutting modern technology.

In this tutorial, we will demonstrate a few examples of OpenAI’s API using Python and the openai library.

Speech-to-Text on Cloud

“Speech-To-Text on Cloud” refers to the process of generating text from spoken words using cloud computing services. In other words, users can speak into a microphone or phone, and their words are automatically transcribed into text format by leveraging cloud-based tools and resources. This approach is becoming increasingly popular due to its convenience, scalability, and affordability, as it eliminates the need for on-premise hardware and software installations. Cloud providers offer Speech-To-Text services that use algorithms derived from machine learning and natural language processing to convert audio recordings to text accurately, quickly, and with high fidelity.

OpenAI Whisper API: 

Whisper API has recently been made available and it might provide an ideal infrastructure to interact with OpenAI’s popular AI service ChatGPT. Whisper speech-to-text API costs $0.006 per 1 minute audio so it is quite affordable and given the experiences OpenAI recently had with scaling and optimizing their systems, Whisper should provide a flawless experience. AI developers can sign up and get FREE credits to test their API services and the free credits go a very long way in terms of testing and demonstrations.

Google Cloud Speech-to-Text:

Google Cloud Speech-to-Text is a powerful cloud-based speech recognition service that can transcribe audio into text with high accuracy. It can recognize speech in over 120 languages and variants, and supports various audio formats such as FLAC, WAV, and MP3. It also supports various features such as real-time streaming and automatic punctuation, and can handle noisy backgrounds and different speaking styles. However, Google’s premium services can be a bit expensive especially if you process a very large volume of data.

Google Speech-to-Text uses deep learning algorithms to convert audio to text. It supports multiple languages and can transcribe audio from various sources, including video files, streaming audio, meeting recordings and telephone calls.

Microsoft Azure Cognitive Services Speech Services: 

Microsoft Azure Speech Services is a cloud-based speech recognition service that offers both speech-to-text and text-to-speech capabilities. It supports various languages and accents, and offers features such as real-time streaming, custom models, and automatic language detection. It also integrates with other Azure services such as Azure Cognitive Services and Azure Machine Learning. However, it can be a bit complicated to set up and configure compared to other services.

Amazon Transcribe: 

Amazon Transcribe is a cloud-based speech recognition service that can convert speech to text in real-time. It supports various audio and video formats, and can recognize speech in multiple languages and accents. It also offers features such as automatic punctuation, speaker identification, and custom vocabularies. However, it doesn’t support streaming transcription, and the accuracy can be affected by background noise or poor audio quality.

IBM Watson Speech to Text: 

IBM Watson Speech to Text is a cloud-based speech recognition service that supports various languages and dialects. It can convert speech to text with high  accuracy and offers features such as speaker diarization, real-time streaming, and custom  models. It also integrates with other IBM Watson services such as Watson Studio and Watson Assistant. However, it can be expensive to use if you process a large volume of data.

Oracle Cloud Infrastructure Speech-to-Text: 

OCI Speech is a cloud-based speech recognition service that uses deep learning algorithms to convert audio to text. It supports multiple languages and can transcribe audio from various sources, including video files, streaming audio, and telephone calls. It also offers real-time transcription and keyword spotting capabilities.

Speechmatics: 

Speechmatics is a cloud-based speech recognition service headquartered in Cambridge, England. The company uses deep learning algorithms to convert audio to text. It supports multiple languages and can transcribe audio from various sources, including video files, streaming audio, and telephone calls. They are highly specialized in speech technologies.

Otter.ai:

Otter.ai is a cloud-based speech recognition web app that uses deep learning algorithms to convert audio to text. It supports multiple languages and can transcribe audio from various sources, including video files, streaming audio, and telephone calls. They have a free tier for individual to try users as well as pro and business tiers. A very modern user interface and with free tier option you can’t really lose much by trying if it seems like an interesting service to you. They provide services for Business and Education applications. Otter.ai is well positioned for the current AI transformation that’s happening in the world right now and their integrated voice assistants can help you save time and get more done.

Other Speech-to-Text Alternatives:

Rev.ai: Rev.ai is a cloud-based speech recognition service that uses deep learning algorithms to convert audio to text. It supports multiple languages and can transcribe audio from various sources, including video files, streaming audio, and telephone calls. Rev.ai has a free trial tier for individual users and also great use case scenarios so you can have a pleasant experience and learn about speech-to-text without even paying anything. That being said their processing cost per minute for audio might need reconsideration after the recent developments such as Whisper API they might have to reconsider their pricing for transcription services.

Speech Recognition Anywhere: Speech Recognition Anywhere is an interesting Chrome extension which can be used for filling forms and other documents and even Google Docs and Spreadsheets. Mostly suitable for individual use cases.

Voicebase: Voicebase is a cloud-based speech recognition service that uses deep learning algorithms to convert audio to text. It supports multiple languages and can transcribe audio from various sources, including video files, streaming audio, and telephone calls. It also offers keyword spotting, entity extraction, and sentiment analysis capabilities. They have specialized services for telecommunication, financial services, healthcare and other industries suitable for enterprise solutions.

Kaldi Speech Recognition Toolkit: Kaldi is an open-source speech recognition toolkit that can be deployed on the cloud. It uses deep learning algorithms to convert audio to text and supports multiple languages. It also offers speaker recognition and language understanding capabilities.

Pros and Cons of Speech-to-text Cloud Services

Pros:

All of these speech-to-text cloud services offer high accuracy and support various languages and accents. They also offer various features such as real-time streaming, speaker identification, and custom vocabularies. Additionally, they can easily integrate with other cloud services and offer developer-friendly APIs and SDKs that can be used with Python and other modern programming languages.

Cons:

However, some of these services can be expensive, especially if you process a large volume of data. Also, the accuracy can be affected by background noise or poor audio quality, and some services such as Amazon Transcribe don’t support streaming transcription. Finally, some services such as Microsoft Azure Speech Services can be a bit complicated to set up and configure compared to other options.

Summary

Bonus) Abstract Base Classes: (ABC)

Abstract Classes are nice alternatives to concrete classes since they conveniently allow multiple inheritence.

They work well with unfinished, concept-like classes hence the name abstract. Abstract classes become functional with methods written in subclasses. When a developer is working with subclasses of an abstract class they know that the class is either incomplete or empty so this gives an opportunity to work with incomplete classes in a structured way. @abstractmethod is a useful decorator for abstract base classes in Python.

Here is an example with an @abstractmethod :

from abc import ABC, abstractmethod
 
class ClassAbstract(ABC):
 
    def __init__(self, val1):
        self.value1 = val1
    
    @abstractmethod
    def under_construction(self):
        pass

class DDD(ClassAbstract):

    def under_construction(self):
        return self.value1
    
data1 = DDD(10)

print(data1.under_construction())

10

While the example demonstrates abstract classes perfectly here are 2 “bad” examples to further elaborate abstract classes:

from abc import ABC, abstractmethod
 
class ClassAbstract(ABC):
 
    def __init__(self, val1):
        self.value1 = val1
    
    @abstractmethod
    def under_construction(self):
        pass

class DDD(ClassAbstract):

    def multiplier(self):
        return self.value1*10
    
data1 = DDD(10)

print(data1.multiplier())

TypeError: Can't instantiate abstract class DDD with abstract methods under_construction

You get the above error because you didn’t modify and complete the incomplete abstractmethod inherited from the abstractclass.

Let’s look at another troubled example:

In this example, abstractmethod is not enforced. This is only good old inheritence and not an abstractclass. It still works even though under_construction method is left untouched.

from abc import ABC, abstractmethod
 
class ClassAbstract:
 
    def __init__(self, val1):
        self.value1 = val1
    
    def under_construction(self):
        pass

class DDD(ClassAbstract):

    def multiplier(self):
        return self.value1*10
    
data1 = DDD(10)

print(data1.multiplier())

100

Bonus) c classes: (cPickle, uJson and others)

If you are serious about execution speed then you should definitely consider mingling with C and C++ in relation with Python.

With the help of C extensions some Python operations can be sped up to 100x, 500x or 1000x.

The details of these concepts is beyond the scope of this Python tutorial but if you’re interested you should definitely check out Cython, distutils and setuptools.

Distutils and setuptools make it possible to write extension modules for Python written in either C or Python or even a mix code.

Cython is a Python-like languages that compiles like C catching up with C speeds in many cases.

CPython, often confused with Cython is a Python implementation in C and it requires writing C code for the most part but both will allow you to write libraries in C that can be implemented in Python such as Python’s standard library numpy.

You can also check out alternative libraries that are already written in C by the community. One example to that is uJSON, an ultra-fast alternative to Python’s standard JSON library, or cPickle as an alternative to Pickle.

Introduction

We are going to need smart engineering solutions to solve our planet’s problems (and soon in other celestial bodies in our solar system) in a smart and scalable manner. Parametric programming is a fantastic approach to optimize efficient engineering methods and achieve those goals.

We recently came across a very interesting platform named VIKTOR which introduces smart app development for engineering with our favorite programming language: Python. The Python-based software is applicable to so many disciplines in the engineering and applied science fields. From material science to organic chemistry, civil engineering to mechanical engineering, Viktor offers an impressive toolbox and takes care of tedious processes such as app hosting, app deployment, intellectual property management and server administration.

In this mini-tutorial we will demonstrate how to create parametric design elements using VIKTOR and Python. VIKTRO also helps package, save, deploy and distribute your engineering app with your colleagues or clients and it can be useful for both engineers and engineering-related business teams as well.

Tutorial: Creating Web Apps with VIKTOR (powered by Python)

Creating a web app is an awesome way to let people interact with your Python code because people everywhere in the world can access it; even the ones without any Python skills can use a graphical interface. It brings a whole another level of visualization and interactivity to your engineering project. First, we will ask VIKTOR to create a folder with an empty app containing all files you need, and then install it. 

Some years ago, you would be right, but nowadays, the low-code app development platform VIKTOR makes it so easy that virtually anyone with Python knowledge can do it.

In this tutorial, we will guide you to build your very first app with VIKTOR. We will start with a blank app and create an interactive 3D model of a radio tower step by step. So, let’s get started!

Note: In case you need it, we included a complete web app code at the end of this tutorial.

Contents:

1. Creating and starting an empty app
2. Creating a 3D model
3. Adding input fields
4. Connecting the input fields to the 3D model
5. Adding a Sphere
6. Adding the mast
7. Adding Materials
8. What is next?
9. All code together

Prerequisites

• A free VIKTOR account
• Installing the free VIKTOR library based on the instructions you receive by mail after making an account
• Some Python programming experience
• Ability to write and use functions
  (You are always welcome to refer to our Python User Functions Exercises and the relevant lesson here as well as any other Python lessons, tutorials and exercises we have to reinforce your programming proficiency.)

Installing VIKTOR

Before we get started, we need to download and install VIKTOR. VIKTOR is the platform that will help us create and host the web app using nothing but Python.

Here, you can create your VIKTOR account for free. Just follow the installation instructions which are pretty straightforward. This will take approximately 10 mins.

Creating, installing and starting an empty app

First, we will first ask VIKTOR to create a folder with an empty app containing all files
you need, and then install it. We will use this app as a basis to make your app. So, let’s get started!

1. In the file explorer, go to the location where you like to store this and other future apps. Let’s assume the folder is called ‘viktor-apps’.
2. Right-click in this folder and click on ‘Open in Terminal’ (or similar, e.g. ‘Open PowerShell window here’) to open the command-line shell, as in the image below. Note that in older versions of Windows, you may need to Shift + Right-click on the folder.

1. On the command line, write the following command:

viktor-cli create-app tower-app

This command creates an app with the name ‘tower-app’. After executing the command, you will find a folder called ‘tower-app’ inside the ‘viktor-apps’ folder.

1. In the PowerShell navigate to the ‘tower-app’ folder:

  cd tower-app

2. Before installing a new app, you need to clear the database by running the following command:

viktor-cli clear

3. Now you can install your app using the command below. Installation can take up to 3 minutes, so just have a little patience and read the information below.

viktor-cli install

The command tells VIKTOR to install the app stored inside the folder where you run the command. That is why we ask you to navigate to the app folder first.

4. Start the app with:

viktor-cli start

Congratulations, your app is up and running! However, do not close your command-line shell; otherwise, your app will stop.

5. Open your app in your browser by visiting VIKTOR cloud as explained in the command-line shell

6. After logging in, open the “Development” card. Great, your app is up and running. Now let’s go to the fun part: start building the 3D model!

Creating a 3D model

In this part of the tutorial, we will create a 3D model of the radio tower using the geometry module. Before we start building the 3D model, let’s check out what the current application looks like.

In your browser,

1. Click on “Create”.
2. Fill in a name in the pop-up
3. Click “Create and open”

You should now see an empty page. So let’s start creating our 3D model.

Add a 3D model to your app

First, we will visualize the base of the radio tower. The base will just be a cylinder, which will have a height and a diameter. The first part is a bit slow, but I promise that we will draw the rest of the tower at lighting speed.

1. Go to the folder tower-app and open app.py in your favourite code editors.
2. Check app.py so that it looks like this:

from viktor.core import ViktorController
from viktor.parametrization import ViktorParametrization

class Parametrization(ViktorParametrization):
     pass

class Controller(ViktorController):
    label = 'VIKTOR Tutorial'
    parametrization = Parametrization

3. On the top, import some additional functions we will need to create the app:

from viktor.geometry import Point,Line,CircularExtrusion,Material,Color
from viktor.views import GeometryView,GeometryResult

4. First we will create a geometry view to show your 3D model and define a function to draw everything. We do this inside your controller like this.

...
class Controller(ViktorController):
  label = 'VIKTOR Tutorial'
  parametrization = Parametrization

  @GeometryView("3D", duration_guess=1)
  def visualize_tower(self, params, **kwargs):
    """Creates the 3D view and visualizes the Radio Tower"""

    return GeometryResult()

• Now we will start drawing. First, let’s define 2 reference points we need for our design:

...
  @GeometryView("3D", duration_guess=1)
  def visualize_tower(self, params, **kwargs):
    """Creates the 3D view and visualizes the Radio Tower"""

    # Reference points

    base_start = Point(0, 0, 0)         #<--- Add this lines
    base_end = Point(0, 0, 50)          #<--- Add this lines

    return GeometryResult()

• To create your base of the tower, we will use CirculerExtrusion, which draws a cylinder following a line between the points base_start and base_end. Under the two point we just created add:

    # Create tower base

    line = Line(base_start, base_end)
    base = CircularExtrusion(diameter=5, line=line)

    return GeometryResult(base)     # <--- don't forget to change this line

• If everything went right, you should be able to see the cylinder in your app. Save the app.py file, go to your app and refresh the page.

Python code up to cylinder creation

In case something went wrong, here you can see the complete code so far. Just copy/paste it in app.py and everything should work.

from viktor.core import ViktorController
from viktor.parametrization import ViktorParametrization
from viktor.geometry import Point, Line, CircularExtrusion, Cone, Sphere, Material, Color
from viktor.views import GeometryResult, GeometryView


class Parametrization(ViktorParametrization):
    pass


class Controller(ViktorController):
    label = 'VIKTOR Tutorial'
    parametrization = Parametrization

    @GeometryView("3D", duration_guess=1)
    def visualize_tower(self, params, **kwargs):
        """Creates the 3D view and visualizes the Radio Tower"""

        # Reference points

        base_start = Point(0, 0, 0)
        base_end = Point(0, 0, 50)

        # Create tower base

        line = Line(base_start, base_end)
        base = CircularExtrusion(diameter=5, line=line)

        return GeometryResult(base)

Adding input fields

We created a 3D model in the last section, but what if you want a user to change the geometry dynamically? Using VIKTOR’s input fields you can. Let’s add a few input fields to change the length, width and height of your cylinder.

• Let’s import the NumberField we need. At the top of you code add:

from viktor.parametrization import NumberField

• Under class Parametrization(ViktorParametrization): we will add 2 fields to change the dimensions of the cylinder, and don’t forget to eliminate pass. You code should look like this:

...
class Parametrization(ViktorParametrization):
    """Parametrization of the Radio Tower"""

    # Base of the tower
    base_height = NumberField("Height base", default=50, min=1)
    base_diameter = NumberField("Diameter base", default=3, min=1)

    #pass  <---- DELETE THIS LINE
    ...

• Again, save the app.py file. Go to your app, refresh the page and see the NumberFields appear in your app.

Did you notice that changing the values does not modify the 3D model? This is because we have not connected the NumberFields to your 3D model yet. We’ll do this next.

All code toghter so far

from viktor.core import ViktorController
from viktor.parametrization import ViktorParametrization, NumberField
from viktor.geometry import Point, Line, CircularExtrusion, Cone, Sphere, Material, Color
from viktor.views import GeometryResult, GeometryView


class Parametrization(ViktorParametrization):
    """Parametrization of the Radio Tower"""

    # Base of the tower
    base_height = NumberField("Height base", default=50, min=1)
    base_diameter = NumberField("Diameter base", default=3, min=1)


class Controller(ViktorController):
    label = 'VIKTOR Tutorial'
    parametrization = Parametrization

    @GeometryView("3D", duration_guess=1)
    def visualize_tower(self, params, **kwargs):
        """Creates the 3D view and visualizes the Radio Tower"""

        # Reference points

        base_start = Point(0, 0, 0)
        base_end = Point(0, 0, 50)

        # Create tower base

        line = Line(base_start, base_end)
        base = CircularExtrusion(diameter=5, line=line)

        return GeometryResult(base)

Connecting the input fields to the 3D model

We’ll connect the input fields to the 3D model to make it dynamic:

• Change the 3rd value of base_end from a static 50 to params.base_height and the value of diameter to params.base_diameter as shown below:

...

     @GeometryView("3D",duration_guess=1)
        def visualize_tower(self, params, **kwargs):
        """Creates the 3D view and visualizes the Radio Tower"""

        # Reference points
        base_start = Point(0, 0, 0)
        base_end = Point(0, 0, params.base_height)      # <--- add params.base_height here

        # Create tower base
        line = Line(base_start, base_end)
        base = CircularExtrusion(diameter=params.base_diameter, line=line)      # <--- params.base_diameter here

        return GeometryResult(base)

• Again, save the app.py file. This time, instead of refreshing your app, just change some input values. Did you see that? VIKTOR updated the app, and your 3D model is now dynamic!

Awesome, we already created a fully functioning parametrized model of a beam including a 3D visualisation! If you were
wondering whether this is a good time: Yes, this is a perfect moment to pat yourself on the back!

How does this work?

So what happens in the background? Each time you change an input parameter, VIKTOR reruns the corresponding code and shows the results in the view. In technical words, your code is stateless.

• All the input parameters are stored in the variable params. That is why it is important to pass it to def visualize_tower(self, params, **kwargs).
• params is a Munch, which is like a Python dictionary. You can access the data inside params using dot-style notation. So, for example, to access height inside params, you write params.height.

Adding a sphere

At the top of the tower we add a Sphere.

1. Let’s import Sphere

from viktor.geometry import Sphere

2. We will add and input field to determine the Sphere’s radius:

...
class Parametrization(ViktorParametrization):

 base_height = NumberField("Height base", default=50, min=1)
 base_diameter = NumberField("Diameter base", default=3, min=1)
 sphere_radius = NumberField("Radius sphere", default=4, min=1)      # <-- Add this line

3. Go to our @GeometryView and add a Sphere under the lines that define the base. Sphere needs a point and a diameter. Don’t forget to return the Sphere at the end, so it is visualized. Your code should look like this:

@GeometryView("3D", duration_guess=1)
def visualize_tower(self, params, **kwargs):
  """Creates the 3D view and visualizes the Radio Tower"""

  # Reference points

  base_start = Point(0, 0, 0)
  base_end = Point(0, 0, params.base_height)

  # Create tower base

  line = Line(base_start, base_end)
  base = CircularExtrusion(diameter=params.base_diameter, line=line)

  # Create tower cabin

  cabin = Sphere(base_end, params.sphere_radius)  # <-- Add this line

  return GeometryResult([base, cabin]) # <--- put base and cabin in a list, so they are shown.

4. Again. Save the file and refresh the app.

Adding the mast

Now that you are used to VIKTOR, we ramp up the speed and quickly add the mast on top of our tower in the exact same way we have done before.

1. Import the code:

from viktor.geometry import Cone

2. Add the NumberField for the mast height:

mast_height = NumberField("Height mast", default=30, min=1)

3. Draw a cone and don’t forget to return it so it is visualized:

# Tower top

top = Cone(diameter=params.base_diameter, height=params.mast_height, origin=base_end) # <-- Add this line

return GeometryResult([base,cabin,top]) # <-- Update this line

4. Save the file and refresh.

Adding materials

Great, we created the full 3D model of the tower, but it is looking a bit pale. Let’s add some color, we don’t want a plane crashing into it 😉

We will add color, by creating some Material and adding them to the 3D models.

1. Import Material and Color:

from viktor.geometry import Material, Color

2. Add materials as constants under the imports and before the Parametrization class:

...

WHITE = Material("White", color=Color.white())  # <-- Add these lines too
RED = Material("Red", color=Color.red())        # <-- Add these lines too

class Parametrization(ViktorParametrization): # <-- this line is just for your reference

...

3. Add the materials to the different geometries we created before, as shown here:

...

# Create tower base
line = Line(base_start, base_end)
base = CircularExtrusion(diameter=params.base_diameter, line=line, material=WHITE)

# Create tower cabin

cabin = Sphere(base_end, params.sphere_radius, material=WHITE)

# Tower top

top = Cone(diameter=params.base_diameter, height=params.mast_height, origin=base_end, material=RED)

4. Save, refresh, and you should have a colorful tower:

What is next?

If you managed to get this far, you have done a great job and successfully built your first Python app with VIKTOR! VIKTOR has a large collection of functions and visualizations that await exploring. Feel free to go and check out their docs and start making your own engineering apps powered by Python.

• Explore the different Input Fields, Option Lists and buttons
• Explore the different visualizations
• See how you can change the layout and style of your app
• Learn how to generate reports automatically
• Download one of the sample apps and tweak them to your needs
• Learn more about VIKTOR’s fundamental concepts
• Look up specific VIKTOR classes and functions in the SDK reference

And if you need any help, want to request features or share your creations, you can head over to the Community Forum.

Final code for parametric Radio Tower design

Just in case, here you can find the complete code of the app:

from viktor.core import ViktorController
from viktor.parametrization import ViktorParametrization, NumberField
from viktor.geometry import Point, Line, CircularExtrusion, Cone, Sphere, Material, Color
from viktor.views import GeometryResult, GeometryView

WHITE = Material("White", color=Color.white())
RED = Material("Red", color=Color.red())


class Parametrization(ViktorParametrization):

  base_height = NumberField("Height base", default=50, min=1)
  base_diameter = NumberField("Diameter base", default=3, min=1)
  sphere_radius = NumberField("Radius sphere", default=4, min=1)
  mast_height = NumberField("Height mast", default=30, min=1)


class Controller(ViktorController):
  label = 'VIKTOR Tutorial'
  parametrization = Parametrization

  @GeometryView("3D", duration_guess=1)
  def visualize_tower(self, params, **kwargs):
    """Creates the 3D view and visualizes the Radio Tower"""

    print("Params:", params)

    # Reference points

    base_start = Point(0, 0, 0)
    base_end = Point(0, 0, params.base_height)

    # Create tower base

    line = Line(base_start, base_end)
    base = CircularExtrusion(diameter=params.base_diameter, line=line, material=WHITE)

    # Create tower cabin

    cabin = Sphere(base_end, params.sphere_radius, material=WHITE)

    # Tower top

    top = Cone(diameter=params.base_diameter, height=params.mast_height, origin=base_end, material=RED)

    return GeometryResult([base, cabin, top])

Now although this web application is pretty simple, it’s effective and useful. Furthermore, this implementation opens a whole new world of opportunities to design engineering apps using minimal Python code base with VIKTOR which can be applied to pretty much any concept under engineering and science subdomains.

VIKTOR takes care of the cybersecurity, hosting, server administration, management of intangible assets such as  intellectual property and low-level programming and the result is an intuitive app creation process which can hopefully yield fruitful  discussions and/or presentations in projects with parametric design elements.

We will be publishing a number of professional Python tutorials in near future to continue demonstrating Python’s potential in sophisticated use cases in the field and help you gain inspiration that can result in real world outcomes.

You can find the Python source code and information regarding dependencies of this app at our Github Repository: Python-3D-Tower-Web-App source code.

Guest Author

Github Code Sharing and Development Platform

Github is a great platform for open source software. It grew so much in recent years as the interest in computer programming grew but it’s also such a great platform for sharing, collaborating and contributing.

A lot of people even create repos (or repositories) as archiving their information in an open environment. 

It’s common to see lists of links, books, movies, knowledge sources etc although it’s mainly developed as a platform to share code.

So, our advice is don’t be shy, jump on the wagon if you don’t have a Github account yet, you will soon discover it offers so many amazing synergies and it’s not that complicated either.

So, in a nutshell, you host and share code on Github, no matter how advanced or basic it is. There is no such criteria as your code must be extraordinary so don’t be intimidated. You can start with something like:

msg = "Hello World!"
print(msg)

just to test the waters…

Creating a Github Account

You can sign up for Github from the top right corner.

Creating a Github Account is simple. Just go to Github Signup Page. Just pick s unique username, set your password and game is on!

Once you sign up, you can start a repo. Think of repositories as individual projects, libraries, software, notebooks or products.

You can have any amount of repository in your Github account.

Just click New Repository and it will take you to repository initialization page.

Creating a Github Repository

Creating a repository is also easy. Just pick up a unique name. This name only has to be unique in your account. It doesn’t have to be globally unique. It will let you know with a green or red pop up message anyway.

You can also write a short description, why not. Although it’s optional it makes sense to at least jot a couple of words.

Recommended Reading:

• Open Source Software Licenses
• Getting Ready for Packaging a Python Library
• Python Packaging Quick Tutorial and Checklist

Some important criteria to consider are:

• • Public vs Private: This option is straightforward. If you’d like to keep your repo as private no one will be able to see it except you and people you assign it to. Public repos are open to public view and contribution. You can also change it later.
  • Adding a README file: Checking this option almost always makes sense. It’s great to have a Readme file, content of which also shows up on the main page of your repository. You can always delete it later if you don’t want it or you can change it as well.
  • Adding a gitignore file: This file tells setup file which files not to include in a setup. So, it’s an ignore template. This is genius because there can be lots of irrelevant files like temp files from your IDE or from Python itself that you actually want to avoid in software development.
  • Adding a licence: Adding license can be more serious than it sometimes seems. If you’re in a rush you can always uncheck this option and add a license you choose later.

Thank you for checking out Github component of the Python packaging series. When you are ready you can also consider uploading your unique Python library to PyPI.

If you need some inspiration check out this post:

I’ve been learning coding. What’s next? (Python Edition)

Nvidia just announced an innovative artificial intelligence application a couple of days ago and it’s big deal for a few reasons.

Let’s take a look at what it is and what it does first:

What is Nvidia Maxine?

Nvidia Maxine is an AI powered video streaming platform for developers. While it’s the platform that provides the technology that can be used for video calls or video conferencing, it’s not the end user product such as:

• Skype, 
• BlueJeans, 
• Microsoft Teams, 
• Google Duo, 
• Hangouts,
• Zoom 

It’s more the technology platform that applications could use if they wanted to.

AI became a chic word that’s used in so many products and/or services today but true AI innovation instantly shows off.

Traditionally, current video codecs (such as H.264) can be quite heavy on the internet connection due to its high quality and data size that comes with it. H.264 has been great for videos that are already recorded such as online movies, Netflix, Hulu, Youtube Videos etc. But when it comes to streaming it has the quality we want at a high internet speed cost.

Publicly trading video communications company Zoom has already seen a massive surge in stock prices going up to $485 in the spot market (as of October 7, 2020) from only approximately $70 in early January 2020 shortly before pandemic has broken out ZM:NASDAQ stock price on Google Finance.

What if we could have the support of predictive AI technology that made the application require 1/10 of the data size for a very similar image quality? That’s what Nvidia did.

At this level Zoom’s market capitalization surpasses IBM’s approximate market cap of $110 billion US (IBM Market Capitalization Data on Nasdaq: IBM:NASDAQ) with $125 billion US.

Why is Nvidia Maxine special?

Nvidia’s Maxine implements Generative adversarial network, GANs, to create a deep fake of your own self.

Basically, what happens is, once the deep fake structure is created your movements, mimics, facial expressions, gestures and mannerism are transferred through the AI powered image that’s displayed to your counterparty. Apparently this allows massive amounts of data saving without overwhelming GPU or CPU too much.

We have already been seeing funny (or scary depending on the application and from where you look at) deep fake videos surface the internet recently. This is the immature phase of a technology when it first emerges and nobody is quite sure what to do with it.

I believe if Nvidia Maxine is mass adapted, which it definitely might especially if it can achieve its promises like 10x data saving, this will be the beginning of a new are where AI and particularly GAN are becoming mature end-user products and services.

Given the pandemic, more people than ever need this technology at affordable rates and 

Nvidia’s AI innovation couldn’t be timelier.

Given the public activities on Nvidia’s public Github repository and their extensive usage of Pytorch and Tensorflow for machine learning applications, Nvidia is highly likely to be using Python for their Maxine streaming platform as well.

Although Nvidia states the data size savings are up to 10x on the official webpage of Maxine here. In the promotion video Bandwidth usage per frame is announced as almost 900x ( 97KB vs 0.11KB ). There seems to be a confusion here but moving passed that, 10x data reduction without much quality loss is still huge deal.

On top of data savings Nvidia Maxine also promises to convert videos with 360p quality to 720p in a very realistic way. Here is the interesting promotion video from Nvidia AI Research:

Global Internet Usage

As of 2020, approximately 4.5 billion people have some form of internet access while 3.5 billion people still has no internet access whatsoever. 

According to UNESCO data this approximately corresponds to a ratio of 55% to  45% over the global population. This is absolutely a heart-breaking number considering how much we get done through the internet today both for business and pleasure.

During the pandemic times of Covid-19, for 100s of millions of people video conferencing has been a life saver (in addition to yoga, online shopping, dark chocolate, video games, video streaming services and remote work to name a few). Unfortunately, not all of us are equally blessed with the availability of tech at the tip of our fingers. 

On the flip side though, we have some good news. Internet usage stats will continue to get better and according to Cybersecurity Almanac (co-published by Cybersecurity Ventures and Cisco), global internet access percentage will increase to 6 billion in 2022 and all the way up to 7.5 billion in 2030 (90% of the projected population of 6+ yo ).

And, although 55% of the world seems to have access to internet, it doesn’t mean they all have high broadband connections. 6% of internet users in the US and 13% of internet users in Australia still has slow speed internet. (Reference: Weforum Internet Access Article)

Internet access statistics are approximately 9 in 10 in developed countries, 5 in 10 in developing countries and only barely 1 in 10 in underdeveloped countries.

Also, when the internet is less available it tends to be very expensive and restricted and this can be a huge deal breaker for someone trying to put food on the table.

One thing these numbers expose is that video streaming, whether it’s for entertainment, online education (MOOCs) or video conferencing, is still nearly impossible for billions of people in 2020.

This statistical contrast makes it easier to comprehend the need of innovation in video streaming and to what extent it can change lives.

Future of Nvidia Maxine

It’s probably safe to conclude that this is just the beginning. Beginning of a very powerful and disruptive technology starting to creep into our lives.

Given the potential Maxine platforms enables, it’s probably safe to assume that its adaptation will be widespread very fast. We will watch and see how thing unfold for Nvidia’s Maxine platform.

Although Maxine already has the potential to make video conferencing available for millions of people with poor internet connection and save data at global scale we can see this application going further in terms of technological innovation.

Some of the applications Nvidia’s Maxine implementation can pioneer are:

• VR
• 3-D holograms
• Online News
• Presentations
• MOOCs
• Podcasts
• Suitable Vlogs

On the flip side, this technology will inevitably also be used by people with malintent and we can see a surge in unpleasant experiences caused by:

• online telemarketing
• impersonation fraud 
• more sophisticated scams
• pranks

You are also more than welcome to visit our recent Machine Learning section.

What is watermarking?

Watermarking is a technology of printing less opaque text or symbols on images and items. Believe it or not it’s considered an ancient technology as old as paper since it’s been used on special letters, stamps and printed currency.

As digital imaging has never been such a humongous part of humans’ lives, the usage, creation and demand related to digital images rises as well. Despite the rise of open source and sharing mentality in the digital community, there seems to still be significant room for watermarking applications and so the demand for innovation continues.

Why Watermarkd?

Watermarkd is a Python library published by Holypython.com under the open source license Apache-2.0.

In this post we will try to demonstrate what can be accomplished with Watermarkd library.

Watermarkd library allows users to handle watermarking operations in Python directly from the terminal or through use of an optional GUI component.

Since it’s specialized only for watermarking tasks, Watermarkd has a very light graphical user interface. You can probably get an image watermarked (or watermarkd!) during the time it takes to start up a major Image Manipulation software.

It has the most commonly used features when it comes to watermarking and expected to cater to 90% or more of the people looking to watermark an image.

How does Watermarkd work?

Currently, Watermarkd library consists of one sole class named Spread which houses two functions that spread out watermark text on image(s):

• single function: Spread.single() can be used to apply watermark on a single image (photo).
• batch function: Spread.batch() can be used to apply watermark to multiple images in a folder.

Below you can see various usage types of Watermarkd Library under four titles:

– Single Function Usage

– Batch Function Usage

– Single Function Usage with GUI

– Batch Function Usage with GUI

Single Function Usage

Single function can be used in two main ways:

• through command line without any interface using its parameters
• through GUI by enabling gui parameter via True boolean.

as simple as passing True argument to gui as below:

single(gui=True)

Let’s first investigate usage scenarios without gui:

import Watermarkd as wmd

wmd.Spread.single(img_path=r"c:/myimage.png")

This code, once executed, will create a watermarkd image on the user’s Desktop. You don’t have to assign gui parameter to False since it’s the default option. So, basically it’s the same thing as this code:

wmd.Spread.single(gui=False, img_path=r"c:/myimage.png")

Also, please note that, when not using gui, the only parameter you have to pass an argument to is img_path, since all the other parameters have default values and hence, they are optional.

Let’s continue to explore other parameters that can be passed to the single function:

• gui, (bool), default False : enables GUI
• img_path, (string), mandatory parameter :signifies image path
• wm_text,  (string), default= “Watermarkd”) : Watermark Text
• wm_trans, (int [1-255]), default= 85 : Signifies Watermark Transparency 
• font_size, (int), default= 55) : Watermark Font Size
• font_name, (string), default= “arial.ttf” : Font Type
• filename, (string), default=”Watermarkd” : File Name for Saving
• save_to_path, (string), default=”Desktop/watermarkd_” : Saving Folder Path
• save_to_suffix, (string), default=”.png” : File Type for Saving 
• output_filename, (default= r”c:/Users/”+user_path+”/Desktop/watermarkd.png”) : File Name For Saving

Here is another example, in which watermark text is assigned to “Inception”:

from Watermarkd import Spread

f = r"c:/Users/ABC/Desktop/film.png"
Spread.single(img_path=f, wm_text="Inception")

Batch Function Usage

Batch function is very similar to single function with a few subtle differences. First and foremost, it handles a folder of images rather than a single image. 

So, img_path parameter is exchanged with folder_path parameter.

Otherwise the rest of the differences are mainly internal which you can check out in the source code if you like.

from Watermarkd import Spread

Spread.batch(folder_path=r"c:/User/ABC/New_Photos")

This code will read all the images from the given folder New_Photos, and create an output folder named Watermarkd_ in user’s Desktop and save all the watermarked files there with the default values for optional parameters. Check out a list of parameters below for adjusting different values such as: watermark text, font size, font type, file name, path name, transparency etc.

If you check out the source code, most of the variable names are also conveniently borrowed from the single function.

Regarding the inner workings of the batch function, the main thing is: it doesn’t apply the watermarking algorithm to a single image, instead watermarking algorithm and positioning etc are placed inside a for loop which iterates through the images in the given folder.

So, in simpler words, folder is iterated with a for loop, image file name is taken which becomes the img_path similar to single function, then watermarking is applied and then files is saved and next iteration starts with the next file.

Here is another example:

from Watermarkd import Spread

f=r"c:/User/ABC/New_Photos"
Spread.batch(folder_path=f, wm_text="Photographer A. C. Jonah, #927-654-92**")

• gui, (bool), default False : enables GUI
• folder_path, (string), mandatory parameter  :signifies folder path
• wm_text,  (string), default= “Watermarkd”) : Watermark Text
• wm_trans, (int [1-255]), default= 85 : Signifies Watermark Transparency 
• font_size, (int), default= 55) : Watermark Font Size
• font_name, (string), default= “arial.ttf” : Font Type
• filename, (string), default=”Watermarkd” : File Name for Saving
• save_to_path, (string), default=”Desktop/watermarkd_” : Saving Folder Path
• save_to_suffix, (string), default=”.png” : File Type for Saving 
• output_filename, (default= r”c:/Users/”+user_path+”/Desktop/watermarkd.png”) : File Name For Saving

Watermarkd Usage: Single Function with GUI

Usage with GUI is pretty straightforward.

1. Pick an image file
2. Type your watermark text
3. Choose a watermark text size. Options are:
   • Normal (by default)
   • Small
   • Large
   • Value: Let’s a custom font value to be entered. Possibly something like ~150 for high rez images where something like 30 might suffice for a low resolution image.
4. Transparency: This value defines the transparency (or opacity) of your watermark text. 85 is the default value but you can go all the way down to 0 for a completely transparent text (Watermark would be invisible then). 255, the maximum value will create a solid white watermark text (which is more just a white text than watermark since it’s not transparent at all. It can sometimes be useful nevertheless.)
5. Save as: Different options to save watermarked image as different image types such as:
   1. png (default)
   2. jpg
   3. gif
   4. bmp
6. Save to: Path or folder that you’d like to save your watermarked image to. You can either type it or choose it with the help of the Path button.
7. Filename: Filename you’d like to save your watermarked image under.

Once submit is pressed all the inputs from the user get registered and watermarking process starts.

It can last anywhere between miliseconds to a couple of seconds depending on the resolution of the image. (For the very high resolutions you might need to allow 2-3 seconds which also depends on the availability of computation resources.)

Just as GUI is a new dimension for the Python coder, Packaging also is a new dimension that opens up a whole new world of opportunities and skillset.

To activate GUI component all you have to do is:

Spread.single(gui=True)

You don’t have to pass any other arguments to setting parameters since they’ll be overridden after the GUI is executed.

from Watermarkd import Spread

Spread.single(gui=True)

Watermarkd Usage: Batch Function with GUI

Usage with GUI in batch function is also simple and straightforward. It’s mostly overlapping with single function’s steps. Here are the main differences:

• Pick a folder instead of a single image through the Browse button.
• At the bottom file name will be used as a seed to generate multiple images with watermark. For instance, if you choose Work as file name, files will be saved as Work1.jpg, Work2.jpg, Work3.jpg etc.

Once submit is pressed all the inputs from the user get registered and watermarking process will start.

It can last anywhere between miliseconds to a couple of seconds per image depending on the resolution of the image. (For the very high resolutions you might need to allow 2-3 seconds per image which also depends on the availability of computation resources.)  After that time watermarked images will be created in the specified folder or default folder if none is specified.

Activate graphical user interface for bath watermarking a folder of images similar to the code in single() function’s case:

from Watermarkd import Spread

Spread.batch(gui=True)

Further Steps with Watermarkd

As much as I’d love to see Watermarkd getting used by people with different backgrounds such as:

• Photographers 
• Bloggers
• Entrepreneurs and Business Owners
• Students
• Teachers
• Media Agencies
• Artists, Illustrators

I’d also love to see it being checked out as a learning tool for Python packaging and Python coding in general. It has all the ingredients necessary to comprehend packaging in Python.

Besides packaging topics such as: Pypi repository publishing, Github hosting, licensing etc. It also has fundamental coding topics, but nothing too complicated to discourage an intermediate or even beginner coder, such as:

• For Loop & While Loop
• Conditional Statements (if, elif, else)
• Python Variables
• Data Type Conversions
• Python Classes
• User defined Python functions
• Making use of os library
• File Operations
• Python Operators

Additionally, it’s pretty simple to understand and demonstrates all the ingredients needed to publish a library on PyPI (Python Package Index), such as:

• • setup.py
  • requirements.txt
  • License
  • Readme.md
  • __init__.py

• Graphical User Interface (GUI),
• Databases,
• Packaging,
• Machine Learning,
  
• Open Source Software Licenses
• Open Source Software in general.

Such topics open up whole new worlds for a programmer to progress towards, you can see them as paths you can take in your journey(Oftentimes you can combine these paths for a great product as well).

Final Thoughts

If you’re a beginner or intermediate programmer go ahead and create a Github account. Maybe create a trivial repository where you take some notes and save some files if you like, just to start getting familiar with the environment.

If you like Watermarkd or Holypython’s work in general, you’re welcome to visit our Github repos as well. You can read the Watermarkd.py source code along with other necessary files there (setup.py, requirements.txt, __init__.py etc.). 

As simple as it is, I hope Watermarkd library serves as a practical solution for people who might need watermarking and I’d love to see it serve educational purposes for coders and developers who never had a chance to explore packaging and publishing topics related to Python.

Thank you so much for visiting.

ps: I’d like to thank creators and contributors of Pillow the Friendly PIL Fork and PySimpleGUI libraries for creating such fantastic libraries and influencing further developments. Also, a huge thank you to Stack Overflow community for sharing so much expert level knowledge and being so kind.

This page is a practical summary version of all the steps involved in Python library packaging. You can also find links for longer versions of each step with more detailed explanations, comments and remedies for potential pitfalls at the bottom of this page along with a Python packaging checklist.

If you’re reading this tutorial you might already have a cool invention or an improved version of some other program. In that case congratulations! You’re one step closer to creating wealth for yourself and also for the world.

If you don’t have something tangible yet don’t worry, it’s something that comes with sustained practice. I don’t mean to be corny but, just continue coding and exploring and if you stay at it it’s almost guaranteed to happen. When the inspiration is there though, it’s advised not to sleep on it, so when the moment comes, don’t put it off, don’t delay, act and realize!

So, here is a summary of the major Python packaging cornerstones:

1. Getting the Code Ready for Packaging
2. Hosting at Github
3. Open Source Software Licenses
4. Necessary Files (setup.py, readme.md, license, __init__.py, requirements.txt, setup.cfg)
5. Local Installation, tests and __init__.py File
6. Uploading to PyPI with Twine

At some point in your coding journey, eventually you realize the power of publishing. Open source is really cool and it enables sharing technical knowledge and intellectual products at an unprecedented level. But only when you experience first hand:

• An open source program development on Github
• Publishing your program on a library like Pypi. Maybe at different stages like:
  • Pre-alpha,
  • Alpha,
  • Beta,
  • Release Candidate,
  • Stable Release)

you really start to feel the incredible power of open source synergies.

It is recommended to every programmer, yet, the knowledge gap seems to prevent many people from getting to that stage.

It’s not that difficult, but there is an open source terminology involved which can be confusing for a lot of people.

This is a huge value loss for everyone, for the programmer, for his environment, eventually for the whole world. Because you never know how far that programmer is going to be able to go if those gaps are bridged and dots are connected.

So, hopefully this Python tutorial empowers coders at the beginning stages of their journey and helps them understand how to package Python code, how to create a library, how to create a module. You might not necessarily be a beginner programmer, but you might not have discovered these topics yet or had the opportunity or occasion for it.

Nevertheless, understanding library structures and entering open source world really expands a coders horizons and we recommend stepping into this knowledge space as soon as possible since the benefits are so high.

You might have just learned how to print “Hello World” or you might actually be producing advanced level programs already and just not have stumbled upon this knowledge yet. In the end, it’s all good. Everyone’s journey is unique and it’s important to embrace and strive to progressively move forward.

Let’s check out the general frame of the packaging process and if you’d like to go deeper in any of the steps we have links for that too.

Python Packaging Preparation

After you have a functioning code you will want to do a certain type of cleaning up on it because, code in a library is slightly different than the code in a local .py file that’s used for personal tasks and development. Here are some common practices:

• Clean up the unnecessary comments
• Clean up the part or all of print functions not to cloud user’s terminal too much
• If something can be expressed as a user-defined function, then consider building some functions.
• Tidy up via Python classes. Try to place everything inside a class or multiple classes. User-defined functions can be run from inside the class when needed. For example:
  • class A:
    • def alpha():
• A.alpha()

Before we advance, and after certain improvements on your code you also need a few tools for packaging so you might want to get them ready. These are:

1. A Github account
2. A PyPI account
3. Command Prompt that works with Python (or PowerShell), we suggest Anaconda Command Prompt as a practical and complete solution.
4. twine library installed in Python for uploading to PyPI

Creating a Github Repository

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut elit tellus, luctus nec ullamcorper mattis, pulvinar dapibus leo.

python setup.py sdist

Choosing a license

If you’re sharing your code you need a license so that important aspects of usage, development, price, modification, reselling, responsibility, sublicensing etc. are more clear.

Most common open source licenses are:

Apache-2.0

GNU GPL

GNU LGPL

MIT License

BSD Licenses

More on open source licenses here.

Necessary Files

You need a couple of files that you might not be familiar with in order to package your Python library and turn it into an installable repository. These files are:

setup.py

requirements.txt (optional)

readme.md (optional)

setup.cfg (optional)

__init__.py (optional)

So, before being misleading, although it seems only setup.py is obligatory for Python installation and this is technically true, all of the files above are pretty obligatory in practical sense. You don’t really want to miss any of them.

python setup.py sdist

Creating a Release on Github

Github is a great platform for coding collaboration, version management and open source sharing. It’s free and you simply sign up and create a new repository.

You might want to skip the license selection for your project at the very beginning if you’re not informed on the topic yet.

Local Installation & Testing

First off, you can just navigate to the root folder which hosts your package and import the package after launching Python there. This is as simple as navigating with cd command and then launching Python and trying to import the library as intended.

Eventually though you will want to make a real installation to see if everything is going through smoohtly. 

You can use the code below for a local installation, first create a source distribution, it will create a Python egg and source distribution in the folder where your package exists.

Installing a library locally is very simple and straightforward. Just navigate to the package’s root folder where setup.py can be found and execute the command below:

pip install .

This one will properly install the package inside the site-packages folder under your Python installation folder.

It can be more convenient if you don’t want to have to navigate to the specific directory to import your library and it’s still a local installation and has nothing to do with uploading.

After installation is successful, you can just import your library like any other library:

import [library_I_developed]

At this point, you can make the final checks, see if library is installing and functioning as it’s supposed to, you can also check if __init__.py files are functioning properly and creating the correct importing structure you intend for your users.

Uploading to PyPI

If everything is looking absolutely fine it’s time to step into the wild. Wild in this case is Python Package Index or PyPI.

Egg and source distribution terminology can be confusing. Source distribution is just your library packaged in a .zip or .tar.gz compressed archive formats. Installation occurs through these source distributions.

Egg is pretty much the same thing and it’s a zip file, it’s just a bit specialized and distinct so it’s extension is .egg instead of .zip. You can still open it as a zip file and check out the content if you’re curious.

So, let’s create the source distribution:

python setup.py sdist

This will create a source distribution which is basically a tar.gz or zip file as mentioned above.

Now you have a source distribution ready to be shipped to PyPI however, it’s beneficial to add one more step. It takes a couple of seconds but it can save you lots of headache.

Using twine check all the distributions inside the package. If there is an error with the setup.py file or readme.md file or any of the other ones, it will tell you what the error is so you can fix it and ship again.

import twine

twine check dist/*

Once everything clears 100%, it’s time to upload. Just execute the command below:
Don’t forget to import twine if you haven’t before.

twine upload dist/*

You’ll be asked your PyPI username and then password, just type those in order and press enter and your package will be uploaded.

If update to PyPI is successful, that means that now your library can be installed on any computer with Python and internet connection all around the world. All that’s needed is the execution of this simple pip command:

pip install [Library_Name]

Just get rid of the brackets around your library name when you’re actually installing it.

Updating the package in PyPI

You will likely have new versions every now and then just create a new source distribution and repeat the check and upload steps and your package will be updated automatically.

python setup.py sdist

import twine

twine check dist/*

twine upload dist/*

After that you might want to update your library in your computer from PyPI. Just run this code for that:

pip install [Library_Name] --upgrade 

If you still have question, each step included here has its own long version below and maybe the answers you’re looking for are there. It can still be a good idea to check them out even if you don’t have any questions since there are some cool knowledge included regarding each step of Python packaging.

Python Packaging Tutorials (Long Versions):

1. Python Packaging Quick Version (this tutorial)
2. Getting the Code Ready for Packaging
3. Hosting at Github
4. Open Source Software Licenses
5. Necessary Files
6. Local Installation, Tests and __init__.py File
7. Uploading to PyPI with Twine