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 _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