utils/camsutil/ptz.py

#!/usr/bin/env python3


import urllib.request
from os import path, sep


class API:
    """
    Creation of a request to the camera API based on the prepared template.
    """
    def __init__(self, host: str, user: str, password: str, template: str,
                 protocol: str = 'http', port: int = 80,  channel: int = 101, vid: int = 1,
                 x: int = 0, y: int = 0, z: int = 0, speed: int = 1, time: int = 100000,
                 text: str = None, enabled: str = 'true'):
        """
        Object constructor
        :param host: hostname or ip address
        :param user: valid user
        :param password: valid password
        :param template: the name of an existing template
        :param protocol: http, https, etc.
        :param port: port number
        :param channel: ptz channel number
        :param vid: video channel id
        :param x: horizontal positioning: azimuth, pan
        :param y: vertical positioning: elevation, tilt
        :param z: zoom direction, absolute zoom
        :param speed: positioning speed: from 1 to 7
        :param time: momentary duration, max 100000ms
        :param text: overlay text content
        :param enabled: enabled (true) or disabled (false) overlay text
        """
        self._host = host
        self._user = user
        self._pswd = password
        self._temp = path.dirname(path.abspath(__file__)) + sep + 'templates' + sep + template
        self._protocol = protocol
        self._port = port
        self._channel = channel
        self._id = vid
        self._x = x
        self._y = y
        self._z = z
        self._speed = speed
        self._time = time
        self._message = text
        self._enabledMessage = enabled
        self._data = ''
        self._type = ''
        self._url = self._protocol + '://' + self._host + ':' + str(self._port)
        self._method = ''

        with open(self._temp) as file:
            content = file.read() \
                .replace('@CHANNEL@', str(self._channel)) \
                .replace('@ID@', str(self._id)) \
                .replace('@XXXX@', str(self._x)) \
                .replace('@YYYY@', str(self._y)) \
                .replace('@ZZZZ@', str(self._z)) \
                .replace('@TTTT@', str(self._time)) \
                .replace('@SSSS@', str(self._speed)) \
                .replace('@MSG@', str(self._message)) \
                .replace('@ENABLED@', str(self._enabledMessage))
            for line in content.splitlines():
                if not ('<!--' in line):
                    self._data += line + '\n'
                elif 'PATH:' in line:
                    self._url += line.split(' ')[2]
                elif 'METHOD:' in line:
                    self._method += line.split(' ')[2]
                elif 'TYPE:' in line:
                    self._type += line.split(' ')[2]

    def call(self):
        """
        Call a request to the camera api
        :return: response from the camera api
        """
        # Preparing authorization
        pswd = urllib.request.HTTPPasswordMgrWithDefaultRealm()
        pswd.add_password(None, self._url, self._user, self._pswd)
        auth = urllib.request.HTTPDigestAuthHandler(pswd)
        urllib.request.install_opener(urllib.request.build_opener(auth))

        # Request
        request = urllib.request.Request(url=self._url, data=bytes(self._data.encode('utf-8')), method=self._method)
        request.add_header('Content-Type', self._type)

        # Response
        response = urllib.request.urlopen(request).read()
        if response.startswith(b'\xff\xd8'):
            return response
        else:
            return str(response.decode('utf-8'))


if __name__ == "__main__":
    from argparse import ArgumentParser

    args = ArgumentParser(
        prog='PTZ',
        description='Creation of a request to the camera API based on the prepared template',
        epilog='Dependencies: Python 3 (tested version 3.9.5)'
    )
    args.add_argument('--host', type=str, required=True,
                      help='hostname or ip address')
    args.add_argument('--user', type=str, required=True,
                      help='valid user')
    args.add_argument('--password', type=str, required=True,
                      help='valid password')
    args.add_argument('--template', type=str, required=True,
                      help='the name of an existing template')
    args.add_argument('--protocol', type=str, default='http', required=False,
                      help='http, https, etc.')
    args.add_argument('--port', type=int, default=80, required=False,
                      help='port number')
    args.add_argument('--channel', type=int, default=101, required=False,
                      help='ptz channel number')
    args.add_argument('--vid', type=int, default=1, required=False,
                      help='video channel id')
    args.add_argument('--x', type=int, default=0, required=False,
                      help='horizontal positioning: azimuth, pan')
    args.add_argument('--y', type=int, default=0, required=False,
                      help='vertical positioning: elevation, tilt')
    args.add_argument('--z', type=int, default=0, required=False,
                      help='zoom direction, absolute zoom')
    args.add_argument('--speed', type=int, default=1, required=False,
                      help='positioning speed: from 1 to 7')
    args.add_argument('--time', type=int, default=100000, required=False,
                      help='momentary duration, max 100000ms')
    args.add_argument('--text', type=str, default=None, required=False,
                      help='overlay text content')
    args.add_argument('--enabled', type=str, default='true', required=False,
                      help='enabled (true) or disabled (false) overlay text')
    args = args.parse_args()

    action = API(
        host=args.host, user=args.user, password=args.password, template=args.template,
        protocol=args.protocol, port=args.port, channel=args.channel, vid=args.vid,
        x=args.x, y=args.y, z=args.z, speed=args.speed, time=args.time,
        text=args.text, enabled=args.enabled
    )
    print(action.call())