From 56af9b2e693ae65fefa7d7fd2baa20031d5a2692 Mon Sep 17 00:00:00 2001 From: George Ohashi Date: Wed, 17 Jan 2024 04:37:28 +0000 Subject: [PATCH 1/2] factory --- src/deepsparse/logger_v2/logger_factory.py | 77 ++++++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 src/deepsparse/logger_v2/logger_factory.py diff --git a/src/deepsparse/logger_v2/logger_factory.py b/src/deepsparse/logger_v2/logger_factory.py new file mode 100644 index 0000000000..a96fac6402 --- /dev/null +++ b/src/deepsparse/logger_v2/logger_factory.py @@ -0,0 +1,77 @@ +# Copyright (c) 2021 - present / Neuralmagic, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from typing import Any, Dict + +from .root_logger import LogType, MetricLogger, PerformanceLogger, SystemLogger +from .utils import import_from_path, import_from_registry + + +ROOT_LOGGER_DICT = { + "system": SystemLogger, + "performance": PerformanceLogger, + "metric": MetricLogger, +} + + +class LoggerFactory: + def __init__(self, config: Dict[str, Dict]): + self.config = config + + self.leaf_logger = {} + self.root_logger_factory = {} + self.logger = {} + + self.build_leaf_logger() + self.build_root_logger() + + self.create() + + def build_leaf_logger( + self, + ): + """Build the leaf logegr singleton""" + logger_config = self.config.get("logger") + for name, init_args in logger_config.items(): + self.leaf_logger[name] = self.instantiate_logger( + name=init_args.pop("name"), + init_args=init_args, + ) + + def build_root_logger(self): + + for log_type, logger in ROOT_LOGGER_DICT.items(): + log_type_args = self.config.get(log_type) + if log_type_args is not None: + self.root_logger_factory[log_type] = logger( + config=self.config[log_type], + leaf_logger=self.leaf_logger, + ) + + def create(self): + self.logger = { + LogType.SYSTEM: self.root_logger_factory.get("system"), + LogType.PERFORMANCE: self.root_logger_factory.get("performance"), + LogType.METRIC: self.root_logger_factory.get("metric"), + } + + def instantiate_logger(self, name: str, init_args: Dict[str, Any] = {}): + if ":" in name: + # path/to/file.py:class_or_func + logger = import_from_path(path=name) + return logger(**init_args) + + logger = import_from_registry(name) + return logger(**init_args) From 40e61fa0b6db1705eb0dd98dfeaab7522f3f2319 Mon Sep 17 00:00:00 2001 From: George Ohashi Date: Fri, 19 Jan 2024 14:35:28 +0000 Subject: [PATCH 2/2] docstring --- src/deepsparse/logger_v2/logger_factory.py | 49 ++++++++++++++++++---- 1 file changed, 42 insertions(+), 7 deletions(-) diff --git a/src/deepsparse/logger_v2/logger_factory.py b/src/deepsparse/logger_v2/logger_factory.py index a96fac6402..a02c51d399 100644 --- a/src/deepsparse/logger_v2/logger_factory.py +++ b/src/deepsparse/logger_v2/logger_factory.py @@ -13,12 +13,16 @@ # limitations under the License. -from typing import Any, Dict +from typing import TYPE_CHECKING, Any, Dict from .root_logger import LogType, MetricLogger, PerformanceLogger, SystemLogger from .utils import import_from_path, import_from_registry +if TYPE_CHECKING: + from deepsparse.loggers_v2.registry.loggers.base_logger import BaseLogger + + ROOT_LOGGER_DICT = { "system": SystemLogger, "performance": PerformanceLogger, @@ -27,6 +31,15 @@ class LoggerFactory: + """ + Factory to obtain root logger entrypoints given config file + + self.leaf_logger # dict{key=logger_id, value=instantiated logger obj} + self.root_logger_factory # dict{key=str, value=RootLogger} + self.logger # dict{key=LOG_TYPE.enum, value=RootLogger} + + """ + def __init__(self, config: Dict[str, Dict]): self.config = config @@ -41,8 +54,15 @@ def __init__(self, config: Dict[str, Dict]): def build_leaf_logger( self, - ): - """Build the leaf logegr singleton""" + ) -> None: + """ + Build the leaf logegr singleton + + Notes: + name is the uuid of the logger, ex. default for + PythonLogger (specified by the user) + + """ logger_config = self.config.get("logger") for name, init_args in logger_config.items(): self.leaf_logger[name] = self.instantiate_logger( @@ -50,7 +70,13 @@ def build_leaf_logger( init_args=init_args, ) - def build_root_logger(self): + def build_root_logger(self) -> None: + """ + Build the root logger factory instantiating the + root loggers with the leaf logger singleton and + its section of the config file + + """ for log_type, logger in ROOT_LOGGER_DICT.items(): log_type_args = self.config.get(log_type) @@ -60,16 +86,25 @@ def build_root_logger(self): leaf_logger=self.leaf_logger, ) - def create(self): + def create(self) -> None: + """Create the entrypoints to access the root loggers""" + self.logger = { LogType.SYSTEM: self.root_logger_factory.get("system"), LogType.PERFORMANCE: self.root_logger_factory.get("performance"), LogType.METRIC: self.root_logger_factory.get("metric"), } - def instantiate_logger(self, name: str, init_args: Dict[str, Any] = {}): + def instantiate_logger( + self, name: str, init_args: Dict[str, Any] = {} + ) -> BaseLogger: + """ + Instiate the logger from `name`, a path or the name of BaseLogger + in the registry. Path example: path/to/file.py:LoggerName + + """ if ":" in name: - # path/to/file.py:class_or_func + # Path example: path/to/file.py:LoggerName logger = import_from_path(path=name) return logger(**init_args)