Maya undo chunk examples

Posted on January 4, 2020 by Jan

# -*- coding: utf-8 -*-
##  Copyright 2019 Trevor van Hoof and Jan Pijpers.
##  Licensed under the Apache License, Version 2.0
##  Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers
##  See the license file attached or on https://www.janpijpers.com/script-licenses/

'''
Name: mayaUndoExample
Description:

two undo examples
one on how to use the undo stack as decorator function

and as inside function
'''

from maya import cmds
import traceback
import pymel.core as pm

def undo( function ):
    '''
        This is a function decorator.
        you can use it by writing @undo one line obove any function.
        before the function gets called an undo chunk is started.
        when the function ends it gets closed.
        Be carefull, if you call the function in itself (recursively) it will break the undo stack.
    :param function:
    :return:
    '''
    def funcCall(*args,**kwargs):

        result = None 
        try:
            ## here we open the undo chunk and we give it the name of the fuction
            cmds.undoInfo( openChunk= True, chunkname = function.__name__ )
            result = function( *args,**kwargs )
        except Exception as e:
            ## If we have an error we will print the stack of the error
            print traceback.format_exc()
            ## we also make sure the maya ui shows an error.
            pm.displayError( "## Error, see script editor: %s"%e )
        finally:
            ## we always need to close the chunk at the end else we corrupt the stack.
            cmds.undoInfo( closeChunk = True )
        return result
    return funcCall 



@undo
def simpleExampleWithDecorator():
    '''
        So here we have the decorator defined above the function definition.
        So before this function is called, an undo chunk is created and closed after the function has finished.
    :return:
    '''
    for i in xrange( 10 ):
        loc = cmds.createNode( "spaceLocator"  )
        cmds.xform(loc, translation=(i,i,i))
simpleExampleWithDecorator()


def undoInFunction( ):

    ## its recomended to always use a try and except with an undo chunk else you need to restart maya when it fails.
    ## here we open the undo chunk and we give it the name of the fuction
    cmds.undoInfo(openChunk=True, chunkname="Example")

    try:
        for i in xrange(10):
            loc = cmds.createNode("spaceLocator")
            cmds.xform(loc, translation=(i, i, i) )
    except Exception as e:
        ## If we have an error we will print the stack of the error
        print traceback.format_exc()
        ## we also make sure the maya ui shows an error.
        pm.displayError("## Error, see script editor: %s" % e)
    finally:
        cmds.undoInfo(openChunk=True, chunkname="Example")

undoInFunction()

QT widgets under mouse

Posted on January 1, 2020 by Jan

# -*- coding: utf-8 -*-
##  Copyright 2019 Trevor van Hoof and Jan Pijpers.
##  Licensed under the Apache License, Version 2.0
##  Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers
##  See the license file attached or on https://www.janpijpers.com/script-licenses/

'''
Name: widgetUnderMouse
Description:

prints and highlights the widget under your mouse.
note that this is supppaaaaaaa hacky! And it will make any qt ui flash and slow down a lot!
But its helpfull when you want to find out what an object is called. I used this a lot in Maya to hack into the UI and add custom widgets.

If you click with the mouse buttons the overlay will stop.

'''

import sys

## Simple pyside 2 or 1 import check.
try:
    PYSIDE_VERSION = 2
    from PySide2.QtWidgets import *
    from PySide2.QtGui import *#QFont, QIcon, QPixmap, QColor
    from PySide2.QtCore import * 
    from PySide2.QtUiTools import * 
    from pyside2uic import compileUi
except:
    from PySide.QtCore import * 
    from PySide.QtGui import * 



def widgets_at(pos, topOnly = False ):
    """Return ALL widgets at `pos`
        It uses the WA_TransparentForMouseEvents trick to find the underlying widgets.
    Arguments:
        pos (QPoint): Position at which to get widgets
    """

    widgets = []
    ## Ask QT what widget is at this position
    widget_at = QApplication.widgetAt(pos)
    if topOnly:
        return [widget_at]
        
    while widget_at:
        widgets.append(widget_at)
        ## Make widget invisible, so the next time we call the widgetAt function
        ## QT will return the underlying widget.
        widget_at.setAttribute(Qt.WA_TransparentForMouseEvents)
        widget_at = QApplication.widgetAt(pos)

    # Restore attributes else nothing will respond to mouse clicks anymore.
    for widget in widgets:
        widget.setAttribute(Qt.WA_TransparentForMouseEvents, False)

    return widgets
    
class Overlay(QWidget):
    def __init__(self, parent=None):
        '''
            This is an overlay that sits across the entire UI.
            This way its easier to track the mouse position and interact with the widgets below it.
        :param parent:
        '''
        super(Overlay, self).__init__(parent)
        self.setAttribute(Qt.WA_StyledBackground)
        self.setStyleSheet("QWidget { background-color: rgba(0, 255, 0, 0) }")
        self.setMouseTracking(True)
        self._widgetsUnderMouse = set()

    def mouseMoveEvent(self, event):
        '''
            For every 'pixel' we move our mouse this function is called.
        :param event:
        :return:
        '''
        ## query the current position
        pos = QCursor.pos()

        ## Find the widgets below the cursor.
        currentWidgets = set( [ widgets_at(pos)[1] ] )

        ## If we have found new widgets.
        if currentWidgets != self._widgetsUnderMouse:
            ## Remove the old outline of the widgets we had before
            self._removeOutline(self._widgetsUnderMouse)
            ## Add a new outline to our new widgets
            self._addOutline(currentWidgets)

            ## Print all widgets we have under our mouse now.
            for w in currentWidgets:
                n = w.objectName()
                print "Name: ",n, "Widget: ", w
            self._widgetsUnderMouse = currentWidgets
        ## Let qt do the rest of its magic.
        return super(Overlay, self).mouseMoveEvent(event)
        
    def mousePressEvent( self, event ):
        '''
            If we click with the left mouse button the overlay stops.
        :param event:
        :return:
        '''
        self.deleteLater()
        return super(Overlay, self).mousePressEvent(event)
        
        
    def _addOutline( self, wList ):
        for w in wList:
            n = w.objectName()
            ## SUUUPER HACK TRICK
            ## We force an object name on the object
            w.setObjectName("AAAAAAA")
            ## Make the object have a red outline with a stylesheet
            w.setStyleSheet('QWidget#AAAAAAA {border: 4px solid red;outline-offset: -2px;}')
            ## Restore the object name
            w.setObjectName(n)
            

    def _removeOutline( self, wList):
        '''
            Not the best idea because we remove all style info,
            actually we should store the style sheet info before setting the outline buuuuuttt you get the idea :D
        :param wList:
        :return:
        '''
        for w in wList:
            w.setStyleSheet("")
    
    def _clearAll(self):
        self._removeOutline(self._widgetsUnderMouse)
    
    def __del__(self):
        self._clearAll()
        self._widgetsUnderMouse = set()
    
def get_maya_window():
    for widget in QApplication.allWidgets():
        try:
            if widget.objectName() == "MayaWindow":
                return widget
        except:
            pass
    return None 
    
    
window = get_maya_window()
app = None 
if not window:
    '''
        If we are not in Maya, we just make an example window 
    '''
    app = QApplication(sys.argv)
    
    window = QWidget()
    window.setObjectName("Window")
    window.setFixedSize(200, 100)

    button = QPushButton("Button 1", window)
    button.setObjectName("Button 1")
    button.move(10, 10)
    button = QPushButton("Button 2", window)
    button.setObjectName("Button 2")
    button.move(50, 15)
    
overlay = Overlay(window)
overlay.setObjectName("Overlay")
overlay.setFixedSize(window.size())
overlay._clearAll()
overlay.show()

if app:
    window.show()
    app.exec_()

QT settings example

Posted on January 1, 2020 by Jan

# -*- coding: utf-8 -*-
##  Copyright 2019 Trevor van Hoof and Jan Pijpers.
##  Licensed under the Apache License, Version 2.0
##  Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers
##  See the license file attached or on https://www.janpijpers.com/script-licenses/

'''
Name: qtSettingExample
Description:

Simple example on how to use qt settings.

The first time you run it, it will say you dint have a last opened project, and set an example path
the second time it will print the value of the example path.


'''

from PySide.QtCore import QSettings ## pip install PySide


if __name__ =="__main__":

    settings = QSettings("Company Name", "Tool Name")

    ## Check if the value already exsited
    stored = settings.value("lastOpenedProject")
    if stored:
        print "We have a last opened project: ", stored
    else:
        print "We dint have a last opened project. Setting the example path."
        ## Saven die bende
        settings.setValue("lastOpenedProject", "C:/some/example.path")

    print "Press enter to exit"
    raw_input()

Show QT widget UI hierarchy

Posted on January 1, 2020 by Jan

# -*- coding: utf-8 -*-
##  Copyright 2019 Trevor van Hoof and Jan Pijpers.
##  Licensed under the Apache License, Version 2.0
##  Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers
##  See the license file attached or on https://www.janpijpers.com/script-licenses/

'''
Name: showQtWidgetHierarchy
Description:

In maya you sometimes want to hack the UI.
Seeng as the UI is made with QT you can hack into it by finding the right node and or widget name.

To make this process easier you can run this script and it will show you the entire hierarchy and return it as a dict

'''


import json

import sys
from PySide.QtGui import * ## pip install PySide

def widgets_recursive(d, widget = None, doPrint =False ):
    if not widget:
        for widget in QApplication.topLevelWidgets():
            get_widget(widget, d, 0, doPrint)
    else:
        get_widget(widget, d, 0, doPrint)
                
def get_widget(w,d, depth = 0, doPrint=False):
    '''
        Recursively searches through all widgets down the tree and prints if desired.
    :param w: the widget to search from
    :param d: the dictionary to add it to
    :param depth: current depth we are at
    :param doPrint: if we need to print
    :return:
    '''
    n = w.objectName()
    n = n if n else str(w)
    if doPrint: print "\t"*depth, n
    newD = {}
    for widget in w.children():
        get_widget(widget, newD, depth +1 )
    d[n] = newD

def get_widget_from_name(name):
    for widget in QApplication.allWidgets():
        try:
            if name in widget.objectName() :
                return widget
        except:
            pass
    return None 

if __name__ =="__main__":

    ## Remove this block if you are running this in maya or something.
    ## Here we make a simple QWindow with a layout and button.
    app = QApplication(sys.argv)
    wid = QWidget()
    wid.setObjectName("myWindow")
    button = QPushButton()
    button.setObjectName("This is my button, there are many like it but this one is mine.")
    lay = QHBoxLayout()
    lay.addWidget(button)
    wid.setLayout(lay)
    wid.show()


    ## Create a simpe dict to hold all the data in the ned.
    widgetHierarchyDict = {}

    ## if you have no idea where to start. Just leave the topWidget argument to None
    ## But if you are in a QT based aplication like Maya you can also start from a widget you know the name of to speed
    ## up the process
    widgetObjectName = None ## "graphEditor1Window"
    topWidget = get_widget_from_name(widgetObjectName)


    ## Recurse over all widgets and store all the information in the provided dict.
    widgets_recursive(widgetHierarchyDict, topWidget)

    ## Print it with json so its nice and clear.
    print json.dumps(widgetHierarchyDict, sort_keys=True, indent = 2 )

Find signals and slots from any QT widget object.

Posted on January 1, 2020 by Jan

# -*- coding: utf-8 -*-
##  Copyright 2019 Trevor van Hoof and Jan Pijpers.
##  Licensed under the Apache License, Version 2.0
##  Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers
##  See the license file attached or on https://www.janpijpers.com/script-licenses/

'''
Name: findSignalsAndSlotsQt

This script gives you all available signals and slots on a qt widget object.
Normally you can just check the documentation, however if custom signals and slots are used its hard to find them.
We do this by using the meta class from the object.

I used this to find the timechanged event on the maya timeControl widget.

'''
import sys
from PySide.QtGui import * ## pip install PySide
from PySide import QtCore
def get_widget(name):
    '''
        Kind of slow method of finding a widget by object name.
    :param name:
    :return:
    '''
    for widget in QApplication.allWidgets():
        try:
            if name in widget.objectName():
                return widget
        except Exception as e:
            print e
            pass
    return None 


def test( *arg, **kwarg):
    '''
        Simple test function to see what the signal sends out.
    :param arg:
    :param kwarg:
    :return:
    '''

    print "The args are: ", arg
    print "The kwargs are: ", kwarg
    print 

if __name__ == "__main__":

    ## Here we make a simple QLineEdit for argument sake ...
    app = QApplication(sys.argv)
    wid = QLineEdit()
    wid.setObjectName("myLineEdit")
    wid.show()

    ## Find the widget by name.
    ## See the qt ui list hierarchy script to find all widgets in a qt ui.
    widgetObjectName = "myLineEdit"
    widgetObject = get_widget(widgetObjectName)
    if not widgetObject:
        raise Exception("Could not find widget: %s" %widgetObjectName)

    ## Sanity check
    if not wid == widgetObject:
        raise Exception("Should not happen.XD")

    ## Get the meta data from this object
    meta = widgetObject.metaObject()

    ## Itterate over the number of methods available
    for methodNr in xrange(meta.methodCount()):
        method = meta.method(methodNr)
        ## If the method is a signal type
        if method.methodType() == QtCore.QMetaMethod.MethodType.Signal:
            ## Print the info.
            print
            print "This is the signal name", method.signature()
            print "These are the signal arguments: ", method.parameterNames()
            ## If the method is a signal type
        if method.methodType() == QtCore.QMetaMethod.MethodType.Slot:
            ## Print the info.
            print
            print "This is the slot name", method.signature()
            print "These are the slot arguments: ", method.parameterNames()

    '''
    output example:
    ...
    This is the signal name textChanged(QString)
    These are the signal arguments:  [PySide.QtCore.QByteArray('')]
    
    This is the signal name textEdited(QString)
    These are the signal arguments:  [PySide.QtCore.QByteArray('')]
    ...
    
    so now you can do
    
    widgetObject.textChanged.connect(test)
    
    any every time the text changes the 'test' function will be called 
    
    '''
    widgetObject.textChanged.connect(test)

    sys.exit(app.exec_())

Get process ID as dict

Posted on December 23, 2019 by Jan

# -*- coding: utf-8 -*-
##  Copyright 2019 Trevor van Hoof and Jan Pijpers.
##  Licensed under the Apache License, Version 2.0
##  Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers
##  See the license file attached or on https://www.janpijpers.com/script-licenses/

'''
Name: getProcessId
Description:

script to get all running processes from tasklist
alternatively you can use wmic for the commandline parameters
i.e. wmic process where caption="bla.exe" get commandline

'''

import json
import subprocess


def get_pdata(name = None):
    '''
        {'Session Name': 'Console',
        'Mem Usage': '7',
        'PID': '15888',
        'Image Name': 'conhost.exe',
        'Session#': '1'}
    '''
    pdata = []

    ## create a startup info so we can hide the window popup.
    startupinfo = subprocess.STARTUPINFO()
    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
    startupinfo.wShowWindow = subprocess.SW_HIDE

    ## run the system command to gte all task info in csv format
    task_list = subprocess.check_output(['tasklist', '/fo', 'csv'], startupinfo = startupinfo).replace('"','')
    taskLines = task_list.splitlines()
    dictHeaders =taskLines.pop(0).split(",")

    ## Itterate over all tasks
    for task_line in taskLines:
        taskDict = {taskData[0]:taskData[1] for taskData in zip(dictHeaders, task_line.split(','))}
        ## Filter on name if so desired
        if name:
            if name.lower() in taskDict["Image Name"].lower():
               pdata.append(taskDict)
        else:
            pdata.append(taskDict)
    return pdata

data = get_pdata()
print json.dumps(data, indent =2, sort_keys=True)

# -*- coding: utf-8 -*-

## Licensed under the Apache License, Version 2.0

## Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers

## See the license file attached or on https://www.janpijpers.com/script-licenses/

'''

Name: getProcessId

Description:

script to get all running processes from tasklist

alternatively you can use wmic for the commandline parameters

i.e. wmic process where caption="bla.exe" get commandline

'''

import json

import subprocess

def get_pdata(name = None):

'''

{'Session Name': 'Console',

'Mem Usage': '7',

'PID': '15888',

'Image Name': 'conhost.exe',

'Session#': '1'}

'''

pdata = []

## create a startup info so we can hide the window popup.

startupinfo = subprocess.STARTUPINFO()

startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW

startupinfo.wShowWindow = subprocess.SW_HIDE

## run the system command to gte all task info in csv format

task_list = subprocess.check_output(['tasklist', '/fo', 'csv'], startupinfo = startupinfo).replace('"','')

taskLines = task_list.splitlines()

dictHeaders =taskLines.pop(0).split(",")

## Itterate over all tasks

for task_line in taskLines:

taskDict = {taskData[0]:taskData[1] for taskData in zip(dictHeaders, task_line.split(','))}

## Filter on name if so desired

if name:

if name.lower() in taskDict["Image Name"].lower():

pdata.append(taskDict)

else:

pdata.append(taskDict)

return pdata

data = get_pdata()

print json.dumps(data, indent =2, sort_keys=True)

Find the offset in seconds between two audio files.

Posted on December 19, 2019 by Jan

I frequently have to sync audio from a boom mic or external mic and camera audio, and without having a clapboard this is quite tedious (even with a clapboard this is tedious XD) hence this script.

See the attached zipped example files for use with this script.

praatSyncWav.zip Example files download.

See http://www.fon.hum.uva.nl/praat/download_win.html
To download the praat tool.

# -*- coding: utf-8 -*-
##  Copyright 2019 Trevor van Hoof and Jan Pijpers.
##  Licensed under the Apache License, Version 2.0
##  Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers
##  See the license file attached or on https://www.janpijpers.com/script-licenses/

'''
Name: find the offset of one wav file to the other.
Description:

This is a common problem with video and audio recording.
Where the sound recording does not start at exactly the same time as the video.

So I use this script to sync the two audio tracks.
It uses a wonderful third party tool called Praat
http://www.fon.hum.uva.nl/praat/
praat license gnu
http://www.fon.hum.uva.nl/praat/GNU_General_Public_License.txt

Note: I recommend converting the wav files to 16 bit 16khz.
That seems to have the best result. else praat will have issues

Note the script only uses the first 30 seconds to compare.
If you reduce this time then the script becomes faster.


If you want to modify the duration edit this line in the .praat script.

    Extract part: 0, 30, "no"

If you want to compare the entire wav file change this to...
    Extract part: 0, 3000000000000000, "no"
or something like that XD
'''


import subprocess


praatExe = r"Praat.exe"
praatScript = r"findWavOffset.praat"

wavFileA =r"bensound-summer.wav"
wavFileB =r"bensound-summer_offset.wav"

## Construct the command
praat_command = '{} --run {} {} {}'.format(
    praatExe, praatScript, wavFileA, wavFileB)


print "Starting praat command please wait a few seconds..."
sound_offset_time = subprocess.check_output( praat_command, shell=True).decode("utf-16")

print "The offset from file B to A is:"
print sound_offset_time ## should be like: 28.750839181733134
print "enter to exit"
raw_input()

# -*- coding: utf-8 -*-

## Licensed under the Apache License, Version 2.0

## Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers

## See the license file attached or on https://www.janpijpers.com/script-licenses/

'''

Name: find the offset of one wav file to the other.

Description:

This is a common problem with video and audio recording.

Where the sound recording does not start at exactly the same time as the video.

So I use this script to sync the two audio tracks.

It uses a wonderful third party tool called Praat

http://www.fon.hum.uva.nl/praat/

praat license gnu

http://www.fon.hum.uva.nl/praat/GNU_General_Public_License.txt

Note: I recommend converting the wav files to 16 bit 16khz.

That seems to have the best result. else praat will have issues

Note the script only uses the first 30 seconds to compare.

If you reduce this time then the script becomes faster.

If you want to modify the duration edit this line in the .praat script.

Extract part: 0, 30, "no"

If you want to compare the entire wav file change this to...

Extract part: 0, 3000000000000000, "no"

or something like that XD

'''

import subprocess

praatExe = r"Praat.exe"

praatScript = r"findWavOffset.praat"

wavFileA =r"bensound-summer.wav"

wavFileB =r"bensound-summer_offset.wav"

## Construct the command

praat_command = '{} --run {} {} {}'.format(

praatExe, praatScript, wavFileA, wavFileB)

print "Starting praat command please wait a few seconds..."

sound_offset_time = subprocess.check_output( praat_command, shell=True).decode("utf-16")

print "The offset from file B to A is:"

print sound_offset_time ## should be like: 28.750839181733134

print "enter to exit"

raw_input()

Trim wave file example with scipy

Posted on December 19, 2019 by Jan

# -*- coding: utf-8 -*-
##  Copyright 2019 Trevor van Hoof and Jan Pijpers.
##  Licensed under the Apache License, Version 2.0
##  Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers
##  See the license file attached or on https://www.janpijpers.com/script-licenses/

'''
Name: scipy wav file
Description:

Usually not a big fan of scipy and numpy cause of no Maya compatability.
But still usefull as an example

'''

from scipy.io import wavfile

def trim_wav( originalWavPath, newWavPath , start, end ):
    '''
    :param originalWavPath: the path to the source wav file
    :param newWavPath: output wav file * can be same path as original
    :param start: time in seconds
    :param end: time in seconds
    :return:
    '''
    sampleRate, waveData = wavfile.read( originalWavPath )
    startSample = int( start * sampleRate )
    endSample = int( end * sampleRate )
    wavfile.write( newWavPath, sampleRate, waveData[startSample:endSample])


wp = r"pathToWav.wav"
trim_wav(wp, wp.replace(".wav", "_trimmed.wav"), 0,10)

# -*- coding: utf-8 -*-

## Licensed under the Apache License, Version 2.0

## Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers

## See the license file attached or on https://www.janpijpers.com/script-licenses/

'''

Name: scipy wav file

Description:

Usually not a big fan of scipy and numpy cause of no Maya compatability.

But still usefull as an example

'''

from scipy.io import wavfile

def trim_wav( originalWavPath, newWavPath , start, end ):

'''

:param originalWavPath: the path to the source wav file

:param newWavPath: output wav file * can be same path as original

:param start: time in seconds

:param end: time in seconds

:return:

'''

sampleRate, waveData = wavfile.read( originalWavPath )

startSample = int( start * sampleRate )

endSample = int( end * sampleRate )

wavfile.write( newWavPath, sampleRate, waveData[startSample:endSample])

wp = r"pathToWav.wav"

trim_wav(wp, wp.replace(".wav", "_trimmed.wav"), 0,10)

Network data packing and unpacking example

Posted on December 19, 2019 by Jan

I spend an unreasonable amount of time trying to figure this out. How to pack your data so you can send it across a TCP connection, receive it on the other side, know what data you received and unpack it accordingly. Hence sharing it, hopefully its useful to someone out there ^_^

# -*- coding: utf-8 -*-
##  Copyright 2019 Trevor van Hoof and Jan Pijpers.
##  Licensed under the Apache License, Version 2.0
##  Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers
##  See the license file attached or on https://www.janpijpers.com/script-licenses/

'''
Name: bytesForNetworkTransfer
Description:

byte tests for data transmission across a network
Simple example on how to create a data packet for sending across a tcp network connection.

'''


import sys
import struct

def create_packet( message, type = 100 ):
    '''
        This packs our string message into a packet that we can send across a network.
        The type makes it easier to know how to handle the data on the receiving end.
        For example, type 100 means normal text data
        but type 200 can mean jpg image data.

        the way we construct our packet is as follows.
        [size][type][message]
        the first part will say how big our message is.
        the second part will hold the type number
        the third part will be the message.

    :param message: a byte string message.
    :param type: the message type. This can be any number between 0 and 255.
    :return:
    '''
    if not isinstance(message, basestring):
        raise TypeError("The message is not a string. ")
    try:
        ## Lets make sure we can encode the data as utf8 and back
        decodedMessage = messageContents.decode("utf8")  ## data is now unicode
        encodedMessage = decodedMessage.encode("utf8")  ## data is now back to binary.
    except UnicodeDecodeError as e:
        print "This message can not be decoded as UTF8. There are characters in there utf8 doesnt understand."
        raise e
   
    ## We use the sys getsizeof function to find out how much bytes this string takes in memory.
    ## using len would give us the number of characters, but not actually the number of bytes.
    messageSize =  sys.getsizeof(message)

    ## Lets start packing this.
    ## For this we use the struct module.
    ## https://docs.python.org/2/library/struct.html

    ## First we write the size.
    ## >I means unsigned int. so a maximum value of 65,535
    ## if you expect bigger messages you should use >Q
    byteString = struct.pack(">I", messageSize)

    ## Then we write the type
    ## >B is an unsigned char. it allows for 256 different types.
    byteString += struct.pack(">B", type)

    ## Now we add our contents.
    byteString += messageContents

    return byteString


def read_packet( incommingMessage ):
    '''
        Here we decode our message.

        There are a few interesting caveats with network data transmission.
        In this case I will assume a tcp network connection.
        That means that "in theory" all the data comes in, in order.

        However you can not always be sure that you received exactly one full message.
        So if we do not have enough data, this function returns [None, remaining data]

        if we have exactly the right amount of data [extracted message, ""]

        if we have more data left [extracted message, remaining data]


        Because we know how we wrote our create packet function,
        we know that the message size is unsigned int( >I ) which is 4 bytes long
        *see the table in the struct python docs

        And the same goes for the type which is 1 byte long.

        so we use that information here.

    :param incommingMessage: the message as we received it from the network.
    :return: list [the message content, the remaining data]
    '''


    if len( incommingMessage ) &lt; 4:
        return [None, incommingMessage]
    sizeBytes = incommingMessage[:4]
    unpackedMessageSize = struct.unpack(">I", sizeBytes)[0]

    typeBytes = incommingMessage[4]
    unpackedMessageType = struct.unpack(">B", typeBytes)[0]

    unpackedMessage = incommingMessage[5:unpackedMessageSize]


    ## Now we could do something with our data and handle it
    ## according to the unpackedMessageType.
    ## i.e.
    ## if unpackedMessageType == 200:
    ##     unpackedMessage = bytes_to_image(unpackedMessage)

    return [unpackedMessage, incommingMessage[unpackedMessageSize+5:]]



## If we do not specify encoding then python will store this string as byte code.
## using japanese characters so we cover some wierd edge cases.
messageContents = "textAnd漢字カタカナ"

## Create the packet ready for sending.
networkPacket = create_packet(messageContents)

## Decode it once we have received it.
decodedMessage, remainingPacketData = read_packet(networkPacket)

print "Original: ", repr(messageContents)
print "Decoded : ", repr(decodedMessage)

assert(messageContents == decodedMessage)

print "All tests passed"

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

# -*- coding: utf-8 -*-

## Licensed under the Apache License, Version 2.0

## Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers

## See the license file attached or on https://www.janpijpers.com/script-licenses/

'''

Name: bytesForNetworkTransfer

Description:

byte tests for data transmission across a network

Simple example on how to create a data packet for sending across a tcp network connection.

'''

import sys

import struct

def create_packet( message, type = 100 ):

'''

This packs our string message into a packet that we can send across a network.

The type makes it easier to know how to handle the data on the receiving end.

For example, type 100 means normal text data

but type 200 can mean jpg image data.

the way we construct our packet is as follows.

[size][type][message]

the first part will say how big our message is.

the second part will hold the type number

the third part will be the message.

:param message: a byte string message.

:param type: the message type. This can be any number between 0 and 255.

:return:

'''

if not isinstance(message, basestring):

raise TypeError("The message is not a string. ")

try:

## Lets make sure we can encode the data as utf8 and back

decodedMessage = messageContents.decode("utf8") ## data is now unicode

encodedMessage = decodedMessage.encode("utf8") ## data is now back to binary.

except UnicodeDecodeError as e:

print "This message can not be decoded as UTF8. There are characters in there utf8 doesnt understand."

raise e

## We use the sys getsizeof function to find out how much bytes this string takes in memory.

## using len would give us the number of characters, but not actually the number of bytes.

messageSize = sys.getsizeof(message)

## Lets start packing this.

## For this we use the struct module.

## https://docs.python.org/2/library/struct.html

## First we write the size.

## >I means unsigned int. so a maximum value of 65,535

## if you expect bigger messages you should use >Q

byteString = struct.pack(">I", messageSize)

## Then we write the type

## >B is an unsigned char. it allows for 256 different types.

byteString += struct.pack(">B", type)

## Now we add our contents.

byteString += messageContents

return byteString

def read_packet( incommingMessage ):

'''

Here we decode our message.

There are a few interesting caveats with network data transmission.

In this case I will assume a tcp network connection.

That means that "in theory" all the data comes in, in order.

However you can not always be sure that you received exactly one full message.

So if we do not have enough data, this function returns [None, remaining data]

if we have exactly the right amount of data [extracted message, ""]

if we have more data left [extracted message, remaining data]

Because we know how we wrote our create packet function,

we know that the message size is unsigned int( >I ) which is 4 bytes long

*see the table in the struct python docs

And the same goes for the type which is 1 byte long.

so we use that information here.

:param incommingMessage: the message as we received it from the network.

:return: list [the message content, the remaining data]

'''

if len( incommingMessage ) < 4:

return [None, incommingMessage]

sizeBytes = incommingMessage[:4]

unpackedMessageSize = struct.unpack(">I", sizeBytes)[0]

typeBytes = incommingMessage[4]

unpackedMessageType = struct.unpack(">B", typeBytes)[0]

unpackedMessage = incommingMessage[5:unpackedMessageSize]

## Now we could do something with our data and handle it

## according to the unpackedMessageType.

## i.e.

## if unpackedMessageType == 200:

## unpackedMessage = bytes_to_image(unpackedMessage)

return [unpackedMessage, incommingMessage[unpackedMessageSize+5:]]

## If we do not specify encoding then python will store this string as byte code.

## using japanese characters so we cover some wierd edge cases.

messageContents = "textAnd漢字カタカナ"

## Create the packet ready for sending.

networkPacket = create_packet(messageContents)

## Decode it once we have received it.

decodedMessage, remainingPacketData = read_packet(networkPacket)

print "Original: ", repr(messageContents)

print "Decoded : ", repr(decodedMessage)

assert(messageContents == decodedMessage)

print "All tests passed"

Zip file example with python.

Posted on December 19, 2019 by Jan

# -*- coding: utf-8 -*-
##  Copyright 2019 Trevor van Hoof and Jan Pijpers.
##  Licensed under the Apache License, Version 2.0
##  Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers
##  See the license file attached or on https://www.janpijpers.com/script-licenses/

'''
Name: zipFileExample
Description:

Simple zipfile example

'''
import zipfile

zipFilePath = r"C:\archive.zip"
with zipfile.ZipFile(zipFilePath, "r") as zFile:
    ## Print all files in filenames.
    for f in zFile.infolist():
        print f.filename
    ## Read a file
    print zFile.read("directory/file_name.extension")

# -*- coding: utf-8 -*-

## Licensed under the Apache License, Version 2.0

## Downloaded from https://janpijpers.com or https://gumroad.com/janpijpers

## See the license file attached or on https://www.janpijpers.com/script-licenses/

'''

Name: zipFileExample

Description:

Simple zipfile example

'''

import zipfile

zipFilePath = r"C:\archive.zip"

with zipfile.ZipFile(zipFilePath, "r") as zFile:

## Print all files in filenames.

for f in zFile.infolist():

print f.filename

## Read a file

print zFile.read("directory/file_name.extension")