145 lines
6.0 KiB
Python
145 lines
6.0 KiB
Python
#!/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())
|