def __init__(self, config):
self.config = config.copy()
if isinstance(config["filepattern"], (str, unicode)):
self.config["filepattern"] = [self.config["filepattern"]]
self.parsers = [Parser(filepattern)
for filepattern in self.config["filepattern"]]
self.aliases = parse_aliases(config)
self.topic = self.config["topic"]
self.tbus_orbit = self.config.get("tbus_orbit", False)
LOGGER.debug("Looking for: %s", str([parser.globify() for parser in self.parsers]))
AbstractWatchDogProcessor.__init__(self,
[parser.globify()
for parser in self.parsers],
config.get("watcher",
"Observer"))
self._pub = NoisyPublisher("trollstalker",
int(self.config["posttroll_port"]),
self.config["topic"])
self.pub = None
obsolete_keys = ["topic", "filepattern", "tbus_orbit",
"posttroll_port", "watch", "config_item", "configuration_file"]
for key in self.config.keys():
if key.startswith("alias_") or key in obsolete_keys:
del self.config[key]
def loadConfig(file, config={}):
logger = logging.getLogger(__name__)
"""
returns a dictionary with keys of the form
<section>.<option> and the corresponding values
"""
config = config.copy()
cp = configparser.RawConfigParser()
cp.read(file)
for sec in cp.sections():
name = str.lower(sec)
for opt in cp.options(sec):
config[name + "." + str.lower(opt)] = str.strip(cp.get(sec, opt))
for entry in config:
if config[entry] == "true":
config[entry] = True
elif config[entry] == "false":
config[entry] = False
try:
var = re.search("%(.+?)%", config[entry]).group(1)
config[entry] = config[entry].replace(
"%" + var + "%", os.environ[var])
except AttributeError:
logger.debug("AttributeError with " + str(config[entry]))
except TypeError:
logger.debug("TypeError with " + str(config[entry]))
except Exception as e:
logger.critical("Unexpected Error " + str(e))
raise SystemExit(e)
return config
def __init__(self, config):
self.config = config.copy()
if isinstance(config["filepattern"], (str, bytes)):
self.config["filepattern"] = [self.config["filepattern"]]
self.parsers = [
Parser(filepattern) for filepattern in self.config["filepattern"]
]
self.aliases = parse_aliases(config)
self.topic = self.config["topic"]
self.tbus_orbit = self.config.get("tbus_orbit", False)
logger.debug("Looking for: %s",
str([parser.globify() for parser in self.parsers]))
AbstractWatchDogProcessor.__init__(
self, [parser.globify() for parser in self.parsers],
config.get("watcher", "Observer"))
self._pub = NoisyPublisher("trollstalker",
int(self.config["posttroll_port"]),
self.config["topic"])
self.pub = None
obsolete_keys = [
"topic", "filepattern", "tbus_orbit", "posttroll_port", "watch",
"config_item", "configuration_file"
]
for key in list(self.config.keys()):
if key.startswith("alias_") or key in obsolete_keys:
del self.config[key]
def update(self, config):
filename = None
if isinstance(config, basestring):
filename = config
config = _Parser().dict_from_file(config)
elif isinstance(config, dict):
config = config.copy()
dict.update(self, config)
if filename and config.has_key('loggers'):
logging.config.fileConfig(filename)
def __init__(self, ip=None, user=None, password=None, config=None, queue=None):
self.communication_queue = deque(tuple(), 256) if queue is None else queue
self.logger = logging.getLogger("PanTilt")
if not config:
config = dict()
config = config.copy()
self.command_urls = config.get('urls', {})
self.return_keys = config.get('keys', {})
self._notified = []
self.return_parser = config.get("return_parser", "plaintext")
format_str = config.get("format_url", "http://{HTTP_login}@{ip}{command}")
self.auth_type = config.get("auth_type", "basic")
self.auth_object = None
if format_str.startswith("http://{HTTP_login}@"):
format_str = format_str.replace("{HTTP_login}@", "")
self.auth_object = HTTPBasicAuth(user or config.get("username", "admin"),
password or config.get("password", "admin"))
self.auth_object_digest = HTTPDigestAuth(config.get("username", "admin"),
config.get("password", "admin"))
self.auth_object = self.auth_object_digest if self.auth_type == "digest" else self.auth_object
self._HTTP_login = config.get("HTTP_login", "{user}:{password}").format(
user=user or config.get("username", "admin"),
password=password or config.get("password", "admin"))
self._url = format_str.format(
ip=ip or config.get("ip", "192.168.1.101:81"),
HTTP_login=self._HTTP_login,
command="{command}")
self._pan_tilt_scale = config.get("scale", 10.0)
self._pan_range = list(config.get("pan_range", [0, 360]))
self._tilt_range = list(config.get("tilt_range", [-90, 30]))
self._position = [0, 0]
self._pan_range.sort()
self._tilt_range.sort()
self._zoom_position = config.get("zoom", 800)
self._zoom_range = config.get("zoom_range", [30, 1000])
self.zoom_position = self._zoom_position
# set zoom position to fill hfov and vfov
# need to set this on camera.
# self._hfov = numpy.interp(self._zoom_position, self.zoom_list, self.hfov_list)
# self._vfov = numpy.interp(self._zoom_position, self.zoom_list, self.vfov_list)
self._accuracy = config.get("accuracy", 0.5)
self._rounding = len(str(float(self._accuracy)).split(".")[-1].replace("0", ""))
time.sleep(0.2)
self.logger.info("pantilt:".format(self.position))
def new_config(new_config):
"""
Temporarily change configuration dictionary.
"""
orig_config = config.copy()
try:
config.clear()
config.update(new_config)
initialize_logging(config)
yield
finally:
config.clear()
config.update(orig_config)
initialize_logging(config)
def __init__(self, identifier: str, config: dict = None, queue: deque = None):
# identifier is NOT OPTIONAL!
# init with name or not, just extending some of the functionality of Thread
super().__init__(name=identifier)
print("Thread started {}: {}".format(self.__class__, identifier))
if queue is None:
queue = deque(tuple(), 256)
self.communication_queue = queue
self.logger = logging.getLogger(identifier)
self.logger.info("Init...")
self.stopper = Event()
self.identifier = identifier
self.config = {}
try:
self.config = config.copy()
except:
pass
self.temperature_multiplier = self.config.get("temperature_multiplier", 10.0)
self.controller = \
self.csv = \
self.out_of_range = \
self.current_timepoint = None
self.lights = []
light_configs = self.config.get("lights", [])
for lc in light_configs:
try:
if lc.get("address", None) is not None:
l = PSILight(lc)
elif lc.get("ip", None) is not None:
l = HelioSpectra(lc)
self.lights.append(l)
except Exception as e:
self.logger.error("Couldnt add light: {}".format(str(e)))
traceback.print_exc()
self.datetimefmt = None
self._current_temp = float()
self._current_wavelength_intentisies = list()
self._current_humidity = float()
self._current_csv_index = 0
self.current_csv_timepoint = datetime.datetime.fromtimestamp(0)
telnet_config = self.config.get('telnet', {})
self.data_fp = self.config.get("datafile")
self.controller = ConvironTelNetController(dict(telnet_config))
self.current_timepoint = datetime.datetime.now()
def new_config(new_config):
"""
Temporarily change configuration dictionary.
"""
from .config import defaults
config = dask.config.config
orig_config = config.copy()
try:
config.clear()
config.update(defaults.copy())
dask.config.update(config, new_config)
initialize_logging(config)
yield
finally:
config.clear()
config.update(orig_config)
initialize_logging(config)
def load_config(file):
"""Load config file
Keyword arguments:
file -- config file path
config -- config array
"""
config = {}
config = config.copy()
cp = configparser.ConfigParser()
cp.read(file)
for sec in cp.sections():
name = sec.lower() # string.lower(sec)
for opt in cp.options(sec):
config[name + "." + opt.lower()] = cp.get(sec, opt).strip()
return config
def new_config(new_config):
"""
Temporarily change configuration dictionary.
"""
from .config import defaults
config = dask.config.config
orig_config = config.copy()
try:
config.clear()
config.update(defaults.copy())
dask.config.update(config, new_config)
initialize_logging(config)
yield
finally:
config.clear()
config.update(orig_config)
initialize_logging(config)
def _posttroll_adder_loop(config, Subscribe, restart_timeout):
"""Run adder until exit via KeyboardInterrupt happens.
Return False if no messages have been received within given time.
"""
cat = georest.connect_to_gs_catalog(config)
latest_message_time = dt.datetime.utcnow()
topics = config["topics"]
services = config.get("services", "")
nameserver = config.get("nameserver", "localhost")
addresses = config.get("addresses")
addr_listener = config.get("use_address_listener", True)
return_value = False
with Subscribe(services=services,
topics=topics,
nameserver=nameserver,
addresses=addresses,
addr_listener=addr_listener) as sub:
try:
for msg in sub.recv(1):
if restart_timeout:
time_since_last_msg = dt.datetime.utcnow(
) - latest_message_time
time_since_last_msg = time_since_last_msg.total_seconds(
) / 60.
if time_since_last_msg > restart_timeout:
logger.debug("%.0f minutes since last message",
time_since_last_msg)
return return_value
if msg is None:
continue
logger.debug("New message received: %s", str(msg))
latest_message_time = dt.datetime.utcnow()
try:
_process_message(cat, config.copy(), msg)
except ValueError:
logger.warning("Filename pattern doesn't match.")
# This is a workaround for the unit tests
return_value = True
except KeyboardInterrupt:
return_value = True
finally:
return return_value # noqa:B012
def __init__(self, config):
self.name = config.get("name")
self.logger = logging.getLogger(self.name)
self.logger.info("PSI light init...")
self.config = config.copy()
self.failed = list()
self.percent = config.get("percent", True)
self.min = 0
# 1022 max value as per psi spec.
self.max = 1022
self.address = int(self.config.get("address", 1))
self.controller = PSISerialInterfaceController(self.address)
self.available_channels = self.config.get("available_channels",
self.default_available_channels)
def configure_logging(config):
config = config.copy()
if config.pop('http_debug', False):
http.client.HTTPConnection.debuglevel = 1
else:
http.client.HTTPConnection.debuglevel = 0
if config.get('coloredlogs'):
conf = config.pop('coloredlogs').copy()
conf['field_styles'] = dict_merge(coloredlogs.DEFAULT_FIELD_STYLES,
conf.get('field_styles', {}))
conf['level_styles'] = dict_merge(coloredlogs.DEFAULT_LEVEL_STYLES,
conf.pop('level_styles', {}))
coloredlogs.install(**conf)
else:
del config['coloredlogs'] # in case 'coloredlogs': null or {}
config.setdefault('version', 1)
logging.config.dictConfig(config)
def __init__(self, config):
self.name = config.get("name")
self.logger = logging.getLogger(self.name)
self.logger.info("Helio init...")
self.config = config.copy()
self.failed = list()
self.percent = config.get("percent", True)
telnet_config = self.config.get('telnet', {})
telnet_config['ip'] = self.config.get('ip')
telnet_config['max'] = self.config.get('max_power', 1000)
telnet_config['min'] = self.config.get('min_power', 0)
self.controller = TelNetController(telnet_config)
http_config = config.get("http", {})
http_config['ip'] = self.config.get('ip')
http_config['max'] = self.config.get('max_power', 1000)
http_config['min'] = self.config.get('min_power', 0)
self.logger.info("Killing the schedule")
HTTPController(http_config).kill_schedule()
# self.wavelengths = self.config.get("wavelengths",
# fallback=["400nm", "420nm", "450nm", "530nm", "630nm", "660nm", "735nm"])
self.wavelengths = self.config.get("wavelengths", self.s20wls)
def instantiate(config: Any, *args: Any, **kwargs: Any) -> Any:
"""
:param config: An config object describing what to call and what params to use.
In addition to the parameters, the config must contain:
_target_ : target class or callable name (str)
And may contain:
_recursive_: Construct nested objects as well (bool).
True by default.
may be overridden via a _recursive_ key in
the kwargs
_convert_: Conversion strategy
none : Passed objects are DictConfig and ListConfig, default
partial : Passed objects are converted to dict and list, with
the exception of Structured Configs (and their fields).
all : Passed objects are dicts, lists and primitives without
a trace of OmegaConf containers
:param args: Optional positional parameters pass-through
:param kwargs: Optional named parameters to override
parameters in the config object. Parameters not present
in the config objects are being passed as is to the target.
:return: if _target_ is a class name: the instantiated object
if _target_ is a callable: the return value of the call
"""
if OmegaConf.is_none(config):
return None
if isinstance(config, TargetConf) and config._target_ == "???":
# Specific check to give a good warning about failure to annotate _target_ as a string.
raise InstantiationException(
f"Missing value for {type(config).__name__}._target_. Check that it's properly annotated and overridden."
f"\nA common problem is forgetting to annotate _target_ as a string : '_target_: str = ...'"
)
if not (
isinstance(config, dict)
or OmegaConf.is_config(config)
or is_structured_config(config)
):
raise HydraException(f"Unsupported config type : {type(config).__name__}")
if isinstance(config, dict):
configc = config.copy()
_convert_container_targets_to_strings(configc)
config = configc
kwargsc = kwargs.copy()
_convert_container_targets_to_strings(kwargsc)
kwargs = kwargsc
# make a copy to ensure we do not change the provided object
config_copy = OmegaConf.structured(config, flags={"allow_objects": True})
if OmegaConf.is_config(config):
config_copy._set_parent(config._get_parent())
config = config_copy
assert OmegaConf.is_config(config)
OmegaConf.set_readonly(config, False)
OmegaConf.set_struct(config, False)
target = _get_target_type(config, kwargs)
try:
config._set_flag("allow_objects", True)
final_kwargs = _get_kwargs(config, **kwargs)
convert = _pop_convert_mode(final_kwargs)
if convert == ConvertMode.PARTIAL:
final_kwargs = OmegaConf.to_container(
final_kwargs, resolve=True, exclude_structured_configs=True
)
return target(*args, **final_kwargs)
elif convert == ConvertMode.ALL:
final_kwargs = OmegaConf.to_container(final_kwargs, resolve=True)
return target(*args, **final_kwargs)
elif convert == ConvertMode.NONE:
return target(*args, **final_kwargs)
else:
assert False
except Exception as e:
# preserve the original exception backtrace
raise type(e)(
f"Error instantiating/calling '{_convert_target_to_string(target)}' : {e}"
).with_traceback(sys.exc_info()[2])
def __init__(self, config=None):
self.logger = logging.getLogger("PanTilt")
if not config:
config = dict()
config = config.copy()
self.command_urls = config.get('urls', {})
self.return_keys = config.get('keys', {})
self._notified = []
self.return_parser = config.get("return_parser", "plaintext")
e = os.environ.get("RETURN_PARSER", None)
e = os.environ.get("PTZ_RETURN_PARSER", e)
self.return_parser = e if e is not None else self.return_parser
format_str = config.get("format_url", "http://{HTTP_login}@{ip}{command}")
e = os.environ.get("FORMAT_URL", None)
e = os.environ.get("PTZ_FORMAT_URL", e)
format_str = e if e is not None else format_str
self.auth_type = config.get("auth_type", "basic")
e = os.environ.get("AUTH_TYPE", None)
e = os.environ.get("PTZ_AUTH_TYPE", e)
self.auth_type = e if e is not None else self.auth_type
self.auth_object = None
username = config.get("username", "admin")
e = os.environ.get("AUTH_USERNAME", None)
e = os.environ.get("PTZ_AUTH_USERNAME", e)
username = e if e is not None else username
password = config.get("password", "admin")
e = os.environ.get("AUTH_PASSWORD", None)
e = os.environ.get("PTZ_AUTH_PASSWORD", e)
username = e if e is not None else username
if format_str.startswith("http://{HTTP_login}@"):
format_str = format_str.replace("{HTTP_login}@", "")
self.auth_object = HTTPBasicAuth(username, password)
self.auth_object_digest = HTTPDigestAuth(username, password)
self.auth_object = self.auth_object_digest if self.auth_type == "digest" else self.auth_object
self._HTTP_login = config.get("HTTP_login", "{user}:{password}").format(user=username, password=password)
ip = config.get("ip", "192.168.1.101:81")
e = os.environ.get("IP", None)
e = os.environ.get("PTZ_IP", e)
ip = ip if e is None else e
self._url = format_str.format(
ip=ip or e,
HTTP_login=self._HTTP_login,
command="{command}")
self._pan_tilt_scale = config.get("scale", 10.0)
e = os.environ.get("PTZ_SCALE", e)
self._pan_tilt_scale = self._pan_tilt_scale if e is None else float(e)
self._pan_range = list(config.get("pan_range", [0, 360]))
e = os.environ.get("PTZ_PAN_RANGE", e)
if e is not None:
e = re.split("[\W+\|,|x|x|:]", e)
e = [float(x) for x in e]
self._pan_range = self._pan_range if e is None else e
self._tilt_range = list(config.get("tilt_range", [-90, 30]))
e = os.environ.get("PTZ_TILT_RANGE", e)
if e is not None:
e = re.split("[\W+\|,|x|x|:]", e)
e = [float(x) for x in e]
self._tilt_range = self._tilt_range if e is None else e
self._position = [0, 0]
self._pan_range.sort()
self._tilt_range.sort()
self._zoom_position = config.get("zoom", 800)
e = os.environ.get("PTZ_ZOOM", e)
self._zoom_position = self._zoom_position if e is None else float(e)
self._zoom_range = config.get("zoom_range", [30, 1000])
e = os.environ.get("PTZ_ZOOM_RANGE", e)
if e is not None:
e = re.split("[\W+\|,|x|x|:]", e)
e = [float(x) for x in e]
self._tilt_range = self._tilt_range if e is None else e
self.zoom_position = self._zoom_position
# set zoom position to fill hfov and vfov
# need to set this on camera.
# self._hfov = numpy.interp(self._zoom_position, self.zoom_list, self.hfov_list)
# self._vfov = numpy.interp(self._zoom_position, self.zoom_list, self.vfov_list)
self._accuracy = config.get("accuracy", 0.5)
e = os.environ.get("PTZ_ACCURACY", e)
self._accuracy = self._accuracy if e is None else float(e)
self._rounding = len(str(float(self._accuracy)).split(".")[-1].replace("0", ""))
time.sleep(0.2)
self.logger.info("pantilt:".format(self.position))
def instantiate(config: Any, *args: Any, **kwargs: Any) -> Any:
"""
:param config: An config object describing what to call and what params to use.
In addition to the parameters, the config must contain:
_target_ : target class or callable name (str)
_recursive_: Construct nested objects as well (bool).
True by default.
may be overridden via a _recursive_ key in
the kwargs
:param args: Optional positional parameters pass-through
:param kwargs: Optional named parameters to override
parameters in the config object. Parameters not present
in the config objects are being passed as is to the target.
:return: if _target_ is a class name: the instantiated object
if _target_ is a callable: the return value of the call
"""
if OmegaConf.is_none(config):
return None
if isinstance(config, TargetConf) and config._target_ == "???":
# Specific check to give a good warning about failure to annotate _target_ as a string.
raise InstantiationException(
f"Missing value for {type(config).__name__}._target_. Check that it's properly annotated and overridden."
f"\nA common problem is forgetting to annotate _target_ as a string : '_target_: str = ...'"
)
if not (
isinstance(config, dict)
or OmegaConf.is_config(config)
or is_structured_config(config)
):
raise HydraException(f"Unsupported config type : {type(config).__name__}")
if isinstance(config, dict):
configc = config.copy()
_convert_container_targets_to_strings(configc)
config = configc
kwargsc = kwargs.copy()
_convert_container_targets_to_strings(kwargsc)
kwargs = kwargsc
# make a copy to ensure we do not change the provided object
config_copy = OmegaConf.structured(config, flags={"allow_objects": True})
if OmegaConf.is_config(config):
config_copy._set_parent(config._get_parent())
config = config_copy
assert OmegaConf.is_config(config)
OmegaConf.set_readonly(config, False)
OmegaConf.set_struct(config, False)
target = _get_target_type(config, kwargs)
try:
config._set_flag("allow_objects", True)
final_kwargs = _get_kwargs(config, **kwargs)
return target(*args, **final_kwargs)
except Exception as e:
raise type(e)(
f"Error instantiating/calling '{_convert_target_to_string(target)}' : {e}"
)
def __init__(self, config):
# probably should be a deep copy for security from plugins
self.__config = config.copy()
def get_config_for_kfold(config, **kwargs):
copy = config.copy()
copy.update(kwargs)
return copy
def __init__(self, config, **kwargs):
"""
Initialiser for cameras...
:param identifier: unique identified for this camera, MANDATORY
:param config: Configuration section for this camera.
:param queue: deque to push info into
:param noconf: dont create a config, or watch anything. Used for temporarily streaming from a camera
:param kwargs:
"""
identifier = config['filenameprefix']
self.logger = logging.getLogger(identifier)
super().__init__(name=identifier)
print("Thread started {}: {}".format(self.__class__, identifier))
self.logger.info("init...")
self.stopper = Event()
self.identifier = identifier
self.name = identifier
self._exif = dict()
self._frame = None
self._image = Image.new('RGB', (1, 1))
# self._image = numpy.empty((Camera.default_width, Camera.default_height, 3), numpy.uint8)
self.config = config.copy()
self.name = self.config.get("filenameprefix", identifier)
self.interval = parse_duration(self.config.get("interval", "10m"))
self.output_directory = "/var/lib/eyepi/{}".format(str(
self.identifier))
# self.begin_capture = datetime.time(0, 0)
# self.end_capture = datetime.time(23, 59)
#
# try:
# self.begin_capture = parser.parse(str(self.config["starttime"]),
# parserinfo=TwentyFourHourTimeParserInfo()).time()
# except Exception as e:
# self.logger.error("Time conversion error starttime - {}".format(str(e)))
# try:
# # cut string to max of 4.
# self.end_capture = parser.parse(str(self.config["stoptime"]),
# parserinfo=TwentyFourHourTimeParserInfo()).time()
# except Exception as e:
# self.logger.error("Time conversion error stoptime - {}".format(str(e)))
try:
if not os.path.exists(self.output_directory):
self.logger.info("Creating local output dir {}".format(
self.output_directory))
os.makedirs(self.output_directory)
except Exception as e:
self.logger.error("Creating directories {}".format(str(e)))
self._exif = self.get_exif_fields()
# self.logger.info("Capturing from {} to {}".format(self.begin_capture.strftime("%H:%M"),
# self.end_capture.strftime("%H:%M")))
self.logger.info("Interval: {}".format(self.interval))
self.current_capture_time = datetime.datetime.now()
def __init__(self, config=None, config_filename=None):
if not config:
config = dict()
if config_filename:
config = yaml.load(open(config_filename).read())
config = config.copy()
self.use_focus_at_center = config.get("use_focus_at_center", True)
e = os.environ.get("USE_FOCUS_AT_CENTER", None)
self.use_focus_at_center = e if e is not None else self.use_focus_at_center
self.name = config.get("name", "DEFAULT_PANO_NAME")
e = os.environ.get("NAME", None)
self.name = e if e is not None else self.name
self.logger = logging.getLogger(self.name)
self._output_dir = config.get("output_dir", "/data")
self.output_dir = self._output_dir
start_time_string = str(config.get('starttime', "0000"))
e = os.environ.get("START_TIME", None)
start_time_string = e if e is not None else start_time_string
end_time_string = str(config.get('stoptime', "2359"))
e = os.environ.get("STOP_TIME", None)
end_time_string = e if e is not None else end_time_string
start_time_string = start_time_string.replace(":", "")
end_time_string = end_time_string.replace(":", "")
start_time_string = start_time_string[:4]
end_time_string = end_time_string[:4]
assert end_time_string.isdigit(), "Non numerical start time, {}".format(str(end_time_string))
self.begin_capture = datetime.datetime.strptime(start_time_string, "%H%M").time()
assert end_time_string.isdigit(), "Non numerical start time, {}".format(str(end_time_string))
self.end_capture = datetime.datetime.strptime(end_time_string, "%H%M").time()
interval = config.get("interval", "1hr")
e = os.environ.get("INTERVAL", None)
interval = e if e is not None else interval
self.interval = parse_time(interval)
camera = None
ptz = None
try:
while not camera:
camera_config = config.get("camera")
if not camera_config:
raise ValueError("No 'camera' section found in config file.")
camera = IPCamera(self.name, config=camera_config)
except Exception as e:
self.logger.error("Couldnt initialise Camera: " + str(e))
time.sleep(30)
camera = None
self._camera = camera
if self._camera:
fov = config.get("camera_fov", None)
e = os.environ.get("CAMERA_FOV", None)
fov = e if e is not None else fov
if type(fov) is str:
fov = re.split("[\W+\|,|x|x|:]", fov)
fov = [float(x) for x in fov]
if fov is not None:
self._camera.hfov, self._camera.vfov = fov
self.logger.debug("Camera initialised")
while not ptz:
try:
ptz_config = config.get("ptz")
if not ptz_config:
raise ValueError("No 'ptz' section found in config file.")
ptz = PanTilt(config=ptz_config)
self.logger.debug("ptz initialised")
except Exception as e:
self.logger.error("Couldnt initialise PTZ: " + str(e))
time.sleep(30)
ptz = None
self._pantilt = ptz
self._zoom_position = config.get('ptz', {}).get('zoom', 800)
self._image_overlap = float(config.get("overlap", 50))
e = os.environ.get("OVERLAP", None)
self._image_overlap = e if e is not None else self._image_overlap
self._image_overlap /= 100
self._seconds_per_image = 5
# this is vital to create the output folder
self._csv_log = None
self._recovery_filepath = os.path.join("/persist", ".gv_recover_{}.json".format(self.name))
self._recovery_file = dict(image_index=0)
try:
if os.path.exists(self._recovery_filepath):
with open(self._recovery_filepath, "r") as file:
self._recovery_file = json.loads(file.read())
except:
with open(self._recovery_filepath, "w+") as f:
f.write("{}")
f.seek(0)
self._recovery_file = json.loads(f.read())
first_corner = config.get("first_corner", [100, 20])
e = os.environ.get("FIRST_CORNER", None)
first_corner = e if e is not None else first_corner
if type(first_corner) is str:
first_corner = re.split("[\W+\|,|x|x|:]", first_corner)
second_corner = config.get("second_corner", [300, -20])
e = os.environ.get("SECOND_CORNER", None)
second_corner = e if e is not None else second_corner
if type(second_corner) is str:
second_corner = re.split("[\W+\|,|x|x|:]", second_corner)
assert type(first_corner) in (list, tuple), "first corner must be a list or tuple"
assert type(second_corner) in (list, tuple), "second corner must be a list or tuple"
assert len(first_corner) == 2, "first corner must be of length 2"
assert len(second_corner) == 2, "second corner must be of length 2"
self._pan_range = sorted([first_corner[0], second_corner[0]])
self._tilt_range = sorted([first_corner[1], second_corner[1]])
self._pan_step = self._tilt_step = None
self._pan_pos_list = self._tilt_pos_list = list()
scan_order_unparsed = config.get("scan_order", "0")
e = os.environ.get("SCAN_ORDER", None)
scan_order_unparsed = e if e is not None else scan_order_unparsed
self._scan_order_translation = {
'cols,right': 0,
'cols,left': 1,
'rows,down': 2,
'rows,up': 3,
"0": 0,
"1": 1,
"2": 2,
"3": 3,
0: 0,
1: 1,
2: 2,
3: 3
}
self._scan_order_translation_r = {
0: 'cols,right',
1: 'cols,left',
2: 'rows,down',
3: 'rows,up'
}
self._scan_order = self._scan_order_translation.get(str(scan_order_unparsed).lower().replace(" ", ""), 0)
self.logger.info(self.summary)
try:
telegraf_client = telegraf.TelegrafClient(host="telegraf", port=8092)
metric = {
"num_rows": len(self._tilt_pos_list),
"num_cols": len(self._pan_pos_list),
"recovery_index": int(self._recovery_file.get("image_index", 0)),
"hfov": self.camera.hfov,
"vfov": self.camera.vfov
}
telegraf_client.metric("gigavision", metric, tags={'name': self.name})
except:
pass
def dictConfig(config):
set_config_function('dict_config', 'config.dictConfig', config.copy())
logging.config.dictConfig(config)
def __init__(self,
ip=None,
user=None,
password=None,
config=None,
queue=None):
self.communication_queue = deque(tuple(),
256) if queue is None else queue
self.logger = logging.getLogger("PanTilt")
if not config:
config = dict()
config = config.copy()
self.command_urls = config.get('urls', {})
self.return_keys = config.get('keys', {})
self._notified = []
self.return_parser = config.get("return_parser", "plaintext")
format_str = config.get("format_url",
"http://{HTTP_login}@{ip}{command}")
self.auth_type = config.get("auth_type", "basic")
self.auth_object = None
if format_str.startswith("http://{HTTP_login}@"):
format_str = format_str.replace("{HTTP_login}@", "")
self.auth_object = HTTPBasicAuth(
user or config.get("username", "admin"), password
or config.get("password", "admin"))
self.auth_object_digest = HTTPDigestAuth(
config.get("username", "admin"),
config.get("password", "admin"))
self.auth_object = self.auth_object_digest if self.auth_type == "digest" else self.auth_object
self._HTTP_login = config.get(
"HTTP_login",
"{user}:{password}").format(user=user
or config.get("username", "admin"),
password=password
or config.get("password", "admin"))
self._url = format_str.format(ip=ip
or config.get("ip", "192.168.1.101:81"),
HTTP_login=self._HTTP_login,
command="{command}")
self._pan_tilt_scale = config.get("scale", 10.0)
self._pan_range = list(config.get("pan_range", [0, 360]))
self._tilt_range = list(config.get("tilt_range", [-90, 30]))
self._position = [0, 0]
self._pan_range.sort()
self._tilt_range.sort()
self._zoom_position = config.get("zoom", 800)
self._zoom_range = config.get("zoom_range", [30, 1000])
self.zoom_position = self._zoom_position
# set zoom position to fill hfov and vfov
# need to set this on camera.
# self._hfov = numpy.interp(self._zoom_position, self.zoom_list, self.hfov_list)
# self._vfov = numpy.interp(self._zoom_position, self.zoom_list, self.vfov_list)
self._accuracy = config.get("accuracy", 0.5)
self._rounding = len(
str(float(self._accuracy)).split(".")[-1].replace("0", ""))
time.sleep(0.2)
self.logger.info("pantilt:".format(self.position))
def __init__(self, config=None, config_filename=None, queue=None):
if not config:
config = dict()
if config_filename:
config = yaml.load(open(config_filename).read())
config = config.copy()
self.use_focus_at_center = config.get("use_focus_at_center", True)
self.name = config.get("name", "DEFAULT_PANO_NAME")
self.logger = logging.getLogger(self.name)
self._output_dir = os.path.join(config.get("output_dir", "/home/images/upload"), self.name)
self.output_dir = self._output_dir
start_time_string = str(config.get('starttime', "0000"))
start_time_string = start_time_string.replace(":", "")
end_time_string = str(config.get('stoptime', "2359"))
end_time_string = end_time_string.replace(":", "")
start_time_string = start_time_string[:4]
end_time_string = end_time_string[:4]
assert end_time_string.isdigit(), "Non numerical start time, {}".format(str(end_time_string))
self.begin_capture = datetime.datetime.strptime(start_time_string, "%H%M").time()
assert end_time_string.isdigit(), "Non numerical start time, {}".format(str(end_time_string))
self.end_capture = datetime.datetime.strptime(end_time_string, "%H%M").time()
self.interval = config.get("interval", 3600)
camera = None
ptz = None
try:
while not camera:
camera_config = config.get("camera")
if not camera_config:
raise ValueError("No 'camera' section found in config file.")
if camera_config == "DSLR":
import gphoto2cffi as gp
cameras = gp.list_cameras()
if not len(cameras):
raise FileNotFoundError("No DSLR connected.")
camera = GPCamera(cameras[0].status.serialnumber, queue=queue)
elif type(camera_config) is dict:
camera = IPCamera(self.name, config=camera_config, queue=queue, noconf=True)
except Exception as e:
self.logger.error("Couldnt initialise Camera: " + str(e))
time.sleep(30)
camera = None
self._camera = camera
if self._camera:
fov = config.get("camera_fov")
if fov:
self._camera.hfov, self._camera.vfov = fov
self.logger.debug("Camera initialised")
while not ptz:
try:
ptz_config = config.get("ptz")
if not ptz_config:
raise ValueError("No 'ptz' section found in config file.")
ptz = PanTilt(config=ptz_config, queue=queue)
self.logger.debug("ptz initialised")
except Exception as e:
self.logger.error("Couldnt initialise PTZ: " + str(e))
time.sleep(30)
ptz = None
self._pantilt = ptz
self._zoom_position = config.get('ptz', {}).get('zoom', 800)
self._image_overlap = float(config.get("overlap", 50)) / 100
self._seconds_per_image = 5
# this is vital to create the output folder
self._csv_log = None
self._recovery_filename = ".gv_recover_{}.json".format(self.name)
self._recovery_file = dict(image_index=0)
try:
if os.path.exists(os.path.join(os.getcwd(), self._recovery_filename)):
with open(os.path.join(os.getcwd(), self._recovery_filename), "r") as file:
self._recovery_file = json.loads(file.read())
except:
with open(os.path.join(os.getcwd(), self._recovery_filename), "w+") as f:
f.write("{}")
f.seek(0)
self._recovery_file = json.loads(f.read())
first_corner = config.get("first_corner", [100, 20])
second_corner = config.get("second_corner", [300, -20])
assert type(first_corner) in (list, tuple), "first corner must be a list or tuple"
assert type(second_corner) in (list, tuple), "second corner must be a list or tuple"
assert len(first_corner) == 2, "first corner must be of length 2"
assert len(second_corner) == 2, "second corner must be of length 2"
self._pan_range = sorted([first_corner[0], second_corner[0]])
self._tilt_range = sorted([first_corner[1], second_corner[1]])
self._pan_step = self._tilt_step = None
self._pan_pos_list = self._tilt_pos_list = list()
scan_order_unparsed = config.get("scan_order", "0")
self._scan_order_translation = {
'cols,right': 0,
'cols,left': 1,
'rows,down': 2,
'rows,up': 3,
"0": 0,
"1": 1,
"2": 2,
"3": 3,
0: 0,
1: 1,
2: 2,
3: 3
}
self._scan_order_translation_r = {
0: 'cols,right',
1: 'cols,left',
2: 'rows,down',
3: 'rows,up'
}
self._scan_order = self._scan_order_translation.get(str(scan_order_unparsed).lower().replace(" ", ""), 0)
self.logger.info(self.summary)
try:
telegraf_client = telegraf.TelegrafClient(host="localhost", port=8092)
metric = {
"num_rows": len(self._tilt_pos_list),
"num_cols": len(self._pan_pos_list),
"recovery_index": int(self._recovery_file.get("image_index", 0)),
"hfov": self.camera.hfov,
"vfov": self.camera.vfov
}
telegraf_client.metric("gigavision", metric, tags={'name': self.name})
except:
pass
