+ 
+ 
+ 
+ 
+
+
+
+[Oleaintueri](https://oleaintueri.com) is sponsoring the development and maintenance of these projects within their organisation.
+
+
+---
+
+### Get started
+
+Implement a "Camera" object by passing it an IP address, Username and Password. By instantiating the object, it will try retrieve a login token from the Reolink Camera. This token is necessary to interact with the Camera using other commands.
+
+See the `examples` directory.
+
+### Using the library as a Python Module
+
+Install the package via Pip
+
+ pip install reolink-api==0.0.5
+
+Install from GitHub
+
+ pip install git+https://github.com/ReolinkCameraAPI/reolink-python-api.git
+
+## Contributors
+
+---
+
+### Styling and Standards
+
+This project intends to stick with [PEP8](https://www.python.org/dev/peps/pep-0008/)
+
+### How can I become a contributor?
+
+#### Step 1
+
+Get the Restful API calls by looking through the HTTP Requests made in the camera's web UI. I use Google Chrome developer mode (ctr + shift + i) -> Network.
+
+#### Step 2
+
+Fork the repository and make your changes.
+
+#### Step 3
+
+Make a pull request.
+
+### API Requests Implementation Plan:
+
+Stream:
+- [X] Blocking RTSP stream
+- [X] Non-Blocking RTSP stream
+
+GET:
+- [X] Login
+- [X] Logout
+- [X] Display -> OSD
+- [X] Recording -> Encode (Clear and Fluent Stream)
+- [X] Recording -> Advance (Scheduling)
+- [X] Network -> General
+- [X] Network -> Advanced
+- [X] Network -> DDNS
+- [X] Network -> NTP
+- [X] Network -> E-mail
+- [X] Network -> FTP
+- [X] Network -> Push
+- [X] Network -> WIFI
+- [X] Alarm -> Motion
+- [X] System -> General
+- [X] System -> DST
+- [X] System -> Information
+- [ ] System -> Maintenance
+- [X] System -> Performance
+- [ ] System -> Reboot
+- [X] User -> Online User
+- [X] User -> Add User
+- [X] User -> Manage User
+- [X] Device -> HDD/SD Card
+- [ ] Zoom
+- [ ] Focus
+- [ ] Image (Brightness, Contrast, Saturation, Hue, Sharp, Mirror, Rotate)
+- [ ] Advanced Image (Anti-flicker, Exposure, White Balance, DayNight, Backlight, LED light, 3D-NR)
+- [X] Image Data -> "Snap" Frame from Video Stream
+
+SET:
+- [X] Display -> OSD
+- [X] Recording -> Encode (Clear and Fluent Stream)
+- [ ] Recording -> Advance (Scheduling)
+- [X] Network -> General
+- [X] Network -> Advanced
+- [ ] Network -> DDNS
+- [ ] Network -> NTP
+- [ ] Network -> E-mail
+- [ ] Network -> FTP
+- [ ] Network -> Push
+- [X] Network -> WIFI
+- [ ] Alarm -> Motion
+- [ ] System -> General
+- [ ] System -> DST
+- [X] System -> Reboot
+- [X] User -> Online User
+- [X] User -> Add User
+- [X] User -> Manage User
+- [X] Device -> HDD/SD Card (Format)
+- [x] PTZ
+- [x] Zoom
+- [x] Focus
+- [X] Image (Brightness, Contrast, Saturation, Hue, Sharp, Mirror, Rotate)
+- [X] Advanced Image (Anti-flicker, Exposure, White Balance, DayNight, Backlight, LED light, 3D-NR)
+
+### Supported Cameras
+
+Any Reolink camera that has a web UI should work. The other's requiring special Reolink clients
+do not work and is not supported here.
+
+- RLC-411WS
+- RLC-423
+- RLC-420-5MP
+- RLC-410-5MP
+- RLC-520
diff --git a/reolink_api/APIHandler.py b/reolink_api/APIHandler.py
deleted file mode 100644
index 093fd2c..0000000
--- a/reolink_api/APIHandler.py
+++ /dev/null
@@ -1,133 +0,0 @@
-import requests
-from reolink_api.resthandle import Request
-from .alarm import AlarmAPIMixin
-from .device import DeviceAPIMixin
-from .display import DisplayAPIMixin
-from .download import DownloadAPIMixin
-from .image import ImageAPIMixin
-from .motion import MotionAPIMixin
-from .network import NetworkAPIMixin
-from .ptz import PtzAPIMixin
-from .recording import RecordingAPIMixin
-from .system import SystemAPIMixin
-from .user import UserAPIMixin
-from .zoom import ZoomAPIMixin
-
-
-class APIHandler(AlarmAPIMixin,
- DeviceAPIMixin,
- DisplayAPIMixin,
- DownloadAPIMixin,
- ImageAPIMixin,
- MotionAPIMixin,
- NetworkAPIMixin,
- PtzAPIMixin,
- RecordingAPIMixin,
- SystemAPIMixin,
- UserAPIMixin,
- ZoomAPIMixin):
- """
- The APIHandler class is the backend part of the API, the actual API calls
- are implemented in Mixins.
- This handles communication directly with the camera.
- Current camera's tested: RLC-411WS
-
- All Code will try to follow the PEP 8 standard as described here: https://www.python.org/dev/peps/pep-0008/
- """
-
- def __init__(self, ip: str, username: str, password: str, https=False, **kwargs):
- """
- Initialise the Camera API Handler (maps api calls into python)
- :param ip:
- :param username:
- :param password:
- :param proxy: Add a proxy dict for requests to consume.
- eg: {"http":"socks5://[username]:[password]@[host]:[port], "https": ...}
- More information on proxies in requests: https://stackoverflow.com/a/15661226/9313679
- """
- scheme = 'https' if https else 'http'
- self.url = f"{scheme}://{ip}/cgi-bin/api.cgi"
- self.ip = ip
- self.token = None
- self.username = username
- self.password = password
- Request.proxies = kwargs.get("proxy") # Defaults to None if key isn't found
-
- def login(self) -> bool:
- """
- Get login token
- Must be called first, before any other operation can be performed
- :return: bool
- """
- try:
- body = [{"cmd": "Login", "action": 0,
- "param": {"User": {"userName": self.username, "password": self.password}}}]
- param = {"cmd": "Login", "token": "null"}
- response = Request.post(self.url, data=body, params=param)
- if response is not None:
- data = response.json()[0]
- code = data["code"]
- if int(code) == 0:
- self.token = data["value"]["Token"]["name"]
- print("Login success")
- return True
- print(self.token)
- return False
- else:
- print("Failed to login\nStatus Code:", response.status_code)
- return False
- except Exception as e:
- print("Error Login\n", e)
- raise
-
- def logout(self) -> bool:
- """
- Logout of the camera
- :return: bool
- """
- try:
- data = [{"cmd": "Logout", "action": 0}]
- self._execute_command('Logout', data)
- # print(ret)
- return True
- except Exception as e:
- print("Error Logout\n", e)
- return False
-
- def _execute_command(self, command, data, multi=False):
- """
- Send a POST request to the IP camera with given data.
- :param command: name of the command to send
- :param data: object to send to the camera (send as json)
- :param multi: whether the given command name should be added to the
- url parameters of the request. Defaults to False. (Some multi-step
- commands seem to not have a single command name)
- :return: response JSON as python object
- """
- params = {"token": self.token, 'cmd': command}
- if multi:
- del params['cmd']
- try:
- if self.token is None:
- raise ValueError("Login first")
- if command == 'Download':
- # Special handling for downloading an mp4
- # Pop the filepath from data
- tgt_filepath = data[0].pop('filepath')
- # Apply the data to the params
- params.update(data[0])
- with requests.get(self.url, params=params, stream=True) as req:
- if req.status_code == 200:
- with open(tgt_filepath, 'wb') as f:
- f.write(req.content)
- return True
- else:
- print(f'Error received: {req.status_code}')
- return False
-
- else:
- response = Request.post(self.url, data=data, params=params)
- return response.json()
- except Exception as e:
- print(f"Command {command} failed: {e}")
- raise
diff --git a/reolink_api/Camera.py b/reolink_api/Camera.py
deleted file mode 100644
index 0a166f1..0000000
--- a/reolink_api/Camera.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from reolink_api import APIHandler
-
-
-class Camera(APIHandler):
-
- def __init__(self, ip: str, username: str = "admin", password: str = "", https: bool = False):
- """
- Initialise the Camera object by passing the ip address.
- The default details {"username":"admin", "password":""} will be used if nothing passed
- :param ip:
- :param username:
- :param password:
- """
- # For when you need to connect to a camera behind a proxy, pass
- # a proxy argument: proxy={"http": "socks5://127.0.0.1:8000"}
- APIHandler.__init__(self, ip, username, password, https=https)
-
- # Normal call without proxy:
- # APIHandler.__init__(self, ip, username, password)
-
- self.ip = ip
- self.username = username
- self.password = password
- super().login()
diff --git a/reolink_api/ConfigHandler.py b/reolink_api/ConfigHandler.py
deleted file mode 100644
index 37f255e..0000000
--- a/reolink_api/ConfigHandler.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import io
-import yaml
-
-
-class ConfigHandler:
- camera_settings = {}
-
- @staticmethod
- def load() -> yaml or None:
- try:
- stream = io.open("config.yml", 'r', encoding='utf8')
- data = yaml.safe_load(stream)
- return data
- except Exception as e:
- print("Config Property Error\n", e)
- return None
diff --git a/reolink_api/RtspClient.py b/reolink_api/RtspClient.py
deleted file mode 100644
index 655f95f..0000000
--- a/reolink_api/RtspClient.py
+++ /dev/null
@@ -1,106 +0,0 @@
-import os
-from threading import ThreadError
-import cv2
-from reolink_api.util import threaded
-
-
-class RtspClient:
- """
- Inspiration from:
- - https://benhowell.github.io/guide/2015/03/09/opencv-and-web-cam-streaming
- - https://stackoverflow.com/questions/19846332/python-threading-inside-a-class
- - https://stackoverflow.com/questions/55828451/video-streaming-from-ip-camera-in-python-using-opencv-cv2-videocapture
- """
-
- def __init__(self, ip, username, password, port=554, profile="main", use_udp=True, callback=None, **kwargs):
- """
- RTSP client is used to retrieve frames from the camera in a stream
-
- :param ip: Camera IP
- :param username: Camera Username
- :param password: Camera User Password
- :param port: RTSP port
- :param profile: "main" or "sub"
- :param use_upd: True to use UDP, False to use TCP
- :param proxies: {"host": "localhost", "port": 8000}
- """
- self.capture = None
- self.thread_cancelled = False
- self.callback = callback
-
- capture_options = 'rtsp_transport;'
- self.ip = ip
- self.username = username
- self.password = password
- self.port = port
- self.proxy = kwargs.get("proxies")
- self.url = "rtsp://" + self.username + ":" + self.password + "@" + \
- self.ip + ":" + str(self.port) + "//h264Preview_01_" + profile
- if use_udp:
- capture_options = capture_options + 'udp'
- else:
- capture_options = capture_options + 'tcp'
-
- os.environ["OPENCV_FFMPEG_CAPTURE_OPTIONS"] = capture_options
-
- # opens the stream capture, but does not retrieve any frames yet.
- self._open_video_capture()
-
- def _open_video_capture(self):
- # To CAP_FFMPEG or not To ?
- self.capture = cv2.VideoCapture(self.url, cv2.CAP_FFMPEG)
-
- def _stream_blocking(self):
- while True:
- try:
- if self.capture.isOpened():
- ret, frame = self.capture.read()
- if ret:
- yield frame
- else:
- print("stream closed")
- self.capture.release()
- return
- except Exception as e:
- print(e)
- self.capture.release()
- return
-
- @threaded
- def _stream_non_blocking(self):
- while not self.thread_cancelled:
- try:
- if self.capture.isOpened():
- ret, frame = self.capture.read()
- if ret:
- self.callback(frame)
- else:
- print("stream is closed")
- self.stop_stream()
- except ThreadError as e:
- print(e)
- self.stop_stream()
-
- def stop_stream(self):
- self.capture.release()
- self.thread_cancelled = True
-
- def open_stream(self):
- """
- Opens OpenCV Video stream and returns the result according to the OpenCV documentation
- https://docs.opencv.org/3.4/d8/dfe/classcv_1_1VideoCapture.html#a473055e77dd7faa4d26d686226b292c1
- """
-
- # Reset the capture object
- if self.capture is None or not self.capture.isOpened():
- self._open_video_capture()
-
- print("opening stream")
-
- if self.callback is None:
- return self._stream_blocking()
- else:
- # reset the thread status if the object was not re-created
- if not self.thread_cancelled:
- self.thread_cancelled = False
- return self._stream_non_blocking()