watchmen-collector-kernel 16.4.7__py3-none-any.whl → 16.4.9__py3-none-any.whl

watchmen_collector_kernel/common/__init__.py

@@ -1,2 +1,2 @@
-from .settings import S3CollectorSettings
-
+from .constants import CHANGE_RECORD_ID, TENANT_ID, IS_MERGED, LEFT_BRACE, RIGHT_BRACE, COMMA, \
+	IS_POSTED, CHANGE_JSON_ID, WAVE, IS_FINISHED, IS_EXTRACTED, MODEL_TRIGGER_ID

watchmen_collector_kernel/common/constants.py

@@ -0,0 +1,16 @@
+
+
+CHANGE_RECORD_ID = 'change_record_id'
+CHANGE_JSON_ID = 'change_json_id'
+TENANT_ID = 'tenant_id'
+MODEL_TRIGGER_ID = 'model_trigger_id'
+
+IS_FINISHED = 'is_finished'
+IS_EXTRACTED = 'is_extracted'
+IS_MERGED = 'is_merged'
+IS_POSTED = 'is_posted'
+
+LEFT_BRACE = '{'
+RIGHT_BRACE = '}'
+COMMA = ','
+WAVE = '~'

watchmen_collector_kernel/model/__init__.py

@@ -1 +1,15 @@
-from .oss_collector_competitive_lock import OSSCollectorCompetitiveLock
+from .competitive_lock import CompetitiveLock
+from .scheduled_task import ScheduledTask
+
+from .collector_model_config import CollectorModelConfig
+from .collector_table_config import CollectorTableConfig
+
+from .trigger_event import TriggerEvent
+from .trigger_model import TriggerModel
+from .trigger_table import TriggerTable
+
+from .change_data_record import ChangeDataRecord
+from .change_data_json import ChangeDataJson
+
+from .condition import construct_conditions, Condition, ConditionJoint, ConditionExpression, \
+	ConditionJointConjunction

watchmen_collector_kernel/model/change_data_json.py

@@ -0,0 +1,28 @@
+from typing import Dict, List
+
+from pydantic import BaseModel
+
+from watchmen_model.common import TenantBasedTuple, Storable
+
+
+class Dependence(Storable, BaseModel):
+	modelName: str
+	objectId: str
+
+
+class ChangeDataJson(TenantBasedTuple, BaseModel):
+	changeJsonId: int
+	resourceId: str
+	modelName: str
+	objectId: str
+	sequence: int
+	content: Dict
+	dataId: Dict
+	dependOn: List[Dependence]
+	isPosted: bool
+	result: Dict
+	taskId: int
+	tableTriggerId: int
+	modelTriggerId: int
+	eventTriggerId: int
+

watchmen_collector_kernel/model/change_data_record.py

@@ -0,0 +1,19 @@
+from typing import Dict, Optional
+
+from watchmen_model.common import TenantBasedTuple
+
+
+class ChangeDataRecord(TenantBasedTuple):
+	changeRecordId: int
+	modelName: str
+	tableName: str
+	dataId: Dict
+	rootTableName: str
+	rootDataId: Dict
+	isMerged: bool
+	result: Dict
+	tableTriggerId: int
+	modelTriggerId: int
+	eventTriggerId: int
+
+

watchmen_collector_kernel/model/collector_model_config.py

@@ -0,0 +1,12 @@
+from typing import List
+from watchmen_model.common import TenantBasedTuple, OptimisticLock
+from pydantic import BaseModel
+
+
+class CollectorModelConfig(TenantBasedTuple, OptimisticLock, BaseModel):
+	modelId: str
+	modelName: str
+	dependOn: List[str]
+	rawTopicCode: str
+	isParalleled: bool
+

watchmen_collector_kernel/model/collector_table_config.py

@@ -0,0 +1,78 @@
+from typing import Dict, List, Optional, Union
+
+from pydantic import BaseModel
+
+from .condition import Condition, construct_conditions
+from watchmen_model.common import TenantBasedTuple, Storable, OptimisticLock
+from watchmen_utilities import ArrayHelper
+
+
+class JoinKey(Storable, BaseModel):
+	parentKey: str = None
+	childKey: str = None
+
+
+class Dependence(Storable, BaseModel):
+	modelName: str
+	objectKey: str  # the dependent column
+
+
+def construct_join_key(join_key: Union[JoinKey, Dict]) -> Optional[JoinKey]:
+	if join_key is None:
+		return None
+	elif isinstance(join_key, JoinKey):
+		return join_key
+	else:
+		return JoinKey(**join_key)
+
+
+def construct_join_keys(join_keys: Optional[List[Union[JoinKey, Dict]]]) -> Optional[List[JoinKey]]:
+	if join_keys is None:
+		return None
+	else:
+		return ArrayHelper(join_keys).map(lambda x: construct_join_key(x)).to_list()
+
+
+def construct_dependence(dependence: Union[Dependence, Dict]) -> Optional[Dependence]:
+	if dependence is None:
+		return None
+	elif isinstance(dependence, Dependence):
+		return dependence
+	else:
+		return Dependence(**dependence)
+
+
+def construct_depend_on(depend_on: Optional[List[Union[Dependence, Dict]]]) -> Optional[List[Dependence]]:
+	if depend_on is None:
+		return None
+	else:
+		return ArrayHelper(depend_on).map(lambda x: construct_dependence(x)).to_list()
+
+
+class CollectorTableConfig(TenantBasedTuple, OptimisticLock, BaseModel):
+	configId: str = None
+	name: str = None
+	tableName: str = None
+	primaryKey: List[str] = None
+	objectKey: str = None
+	sequenceKey: str = None
+	modelName: str = None
+	parentName: str = None
+	label: str = None
+	joinKeys: List[JoinKey] = []
+	dependOn: List[Dependence] = []
+	auditColumn: str = None
+	conditions: List[Condition] = []
+	dataSourceId: str = None
+	isList: bool = False
+	triggered: bool = False
+
+	def __setattr__(self, name, value):
+		if name == 'joinKeys':
+			super().__setattr__(name, construct_join_keys(value))
+		elif name == 'dependOn':
+			super().__setattr__(name, construct_depend_on(value))
+		elif name == 'conditions':
+			super().__setattr__(name, construct_conditions(value))
+		else:
+			super().__setattr__(name, value)

watchmen_collector_kernel/model/competitive_lock.py

@@ -0,0 +1,11 @@
+from datetime import datetime
+from typing import Optional
+
+from watchmen_model.common import CompetitiveLockId, Storable, TenantId
+
+
+class CompetitiveLock(Storable):
+	lockId: CompetitiveLockId
+	resourceId: str
+	registeredAt: Optional[datetime]
+	tenantId: TenantId

watchmen_collector_kernel/model/condition.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from datetime import date, datetime
+from enum import Enum
+from typing import Optional, List, Union, Dict
+
+from pydantic import BaseModel
+
+from watchmen_model.common import DataModel
+from watchmen_utilities import ArrayHelper
+
+
+class ConditionOperator(str, Enum):
+	IS_EMPTY = 'is-empty',
+	IS_NOT_EMPTY = 'is-not-empty',
+	IS_BLANK = 'is-blank',
+	IS_NOT_BLANK = 'is-not-blank',
+	EQUALS = 'equals',
+	NOT_EQUALS = 'not-equals',
+	LESS_THAN = 'less-than',
+	LESS_THAN_OR_EQUALS = 'less-than-or-equals',
+	GREATER_THAN = 'greater-than',
+	GREATER_THAN_OR_EQUALS = 'greater-than-or-equals',
+	IN = 'in',
+	NOT_IN = 'not-in'
+
+
+class Condition(DataModel, BaseModel):
+	pass
+
+
+class ConditionExpression(Condition):
+	columnName: str
+	operator: ConditionOperator = ConditionOperator.EQUALS
+	columnValue: Optional[Union[List[int], List[str], int, str, date, datetime]] = None
+
+
+class ConditionJointConjunction(str, Enum):
+	AND = 'and',
+	OR = 'or'
+
+
+class ConditionJoint(Condition):
+	conjunction: ConditionJointConjunction = ConditionJointConjunction.AND
+	children: List[Condition]
+
+	def __setattr__(self, name, value):
+		if name == 'children':
+			super().__setattr__(name, construct_conditions(value))
+		else:
+			super().__setattr__(name, value)
+
+
+def construct_condition(condition: Optional[Union[Condition, Dict]]) -> Optional[Condition]:
+	if condition is None:
+		return None
+	elif isinstance(condition, Condition):
+		return condition
+	elif isinstance(condition, ConditionExpression):
+		return condition
+	elif isinstance(condition, ConditionJoint):
+		return condition
+	elif condition.get('conjunction'):
+		return ConditionJoint(**condition)
+	else:
+		return ConditionExpression(**condition)
+
+
+def construct_conditions(conditions: Optional[List[Union[Condition, Dict]]]) -> Optional[List[Condition]]:
+	if conditions is None:
+		return None
+	else:
+		return ArrayHelper(conditions).map(lambda x: construct_condition(x)).to_list()

watchmen_collector_kernel/model/scheduled_task.py

@@ -0,0 +1,30 @@
+from typing import Dict, List
+
+from watchmen_model.common import TenantBasedTuple, ScheduledTaskId, Storable
+from pydantic import BaseModel
+from enum import Enum
+
+
+class Result(str, Enum):
+	DEPENDENCY_FAILED = "DEPENDENCY_FAILED"
+	PROCESS_TASK_SUCCESS = "PROCESS_TASK_SUCCESS"
+	PROCESS_TASK_FAILED = "PROCESS_TASK_FAILED"
+
+
+class Dependence(Storable, BaseModel):
+	modelName: str
+	objectId: str
+
+
+class ScheduledTask(TenantBasedTuple, BaseModel):
+	taskId: ScheduledTaskId
+	resourceId: str  # global unique, monotonous increase
+	topicCode: str
+	content: Dict
+	modelName: str
+	objectId: str
+	dependOn: List[Dependence]
+	parentTaskId: List[int]
+	isFinished: bool
+	result: Dict
+

watchmen_collector_kernel/model/trigger_event.py

@@ -0,0 +1,11 @@
+from datetime import datetime
+
+from watchmen_model.common import TenantBasedTuple
+from pydantic import BaseModel
+
+
+class TriggerEvent(TenantBasedTuple, BaseModel):
+	eventTriggerId: int
+	startTime: datetime
+	endTime: datetime
+	isFinished: bool = False

watchmen_collector_kernel/model/trigger_model.py

@@ -0,0 +1,8 @@
+from watchmen_model.common import TenantBasedTuple
+
+
+class TriggerModel(TenantBasedTuple):
+	modelTriggerId: int
+	modelName: str
+	isFinished: bool = False
+	eventTriggerId: int

watchmen_collector_kernel/model/trigger_table.py

@@ -0,0 +1,11 @@
+from watchmen_model.common import TenantBasedTuple
+
+
+class TriggerTable(TenantBasedTuple):
+	tableTriggerId: int
+	tableName: str
+	dataCount: int
+	modelName: str
+	isExtracted: bool = False
+	modelTriggerId: int
+	eventTriggerId: int

watchmen_collector_kernel/service/__init__.py

@@ -0,0 +1,8 @@
+from .lock_helper import try_lock_nowait, unlock
+from .lock_clean import init_lock_clean
+from .trigger_collector import get_trigger_collector
+from .data_capture import DataCaptureService
+from .extract_source import SourceTableExtractor
+from .task_service import get_task_service
+from .criteria_builder import CriteriaBuilder
+from .extract_utils import build_audit_column_criteria, cal_array2d_diff, build_data_id, get_data_id

watchmen_collector_kernel/service/criteria_builder.py

@@ -0,0 +1,53 @@
+from typing import List, Dict, Any
+from watchmen_collector_kernel.common import LEFT_BRACE, RIGHT_BRACE
+from watchmen_collector_kernel.model import Condition, ConditionJoint, ConditionExpression
+from watchmen_data_kernel.common import ask_all_date_formats
+from watchmen_storage import EntityCriteria, EntityCriteriaExpression, ColumnNameLiteral, EntityCriteriaJoint, \
+	EntityCriteriaStatement
+from watchmen_utilities import ArrayHelper, is_date
+
+
+class CriteriaBuilder:
+
+	def __init__(self, variables: Dict):
+		self.variables = variables
+
+	def add_variable(self, variable_name: str, variable_value: Any):
+		self.variables[variable_name] = variable_value
+
+	def build_criteria(self, conditions: List[Condition]) -> EntityCriteria:
+		return ArrayHelper(conditions).map(self.build_statement).to_list()
+
+	def build_statement(self, condition: Condition) -> EntityCriteriaStatement:
+		if isinstance(condition, ConditionJoint):
+			return self.build_criteria_joint(condition)
+		if isinstance(condition, ConditionExpression):
+			return self.build_criteria_expression(condition)
+		else:
+			raise ValueError(f'Unsupported condition[{condition}].')
+
+	def build_criteria_expression(self, condition: ConditionExpression) -> EntityCriteriaExpression:
+		return EntityCriteriaExpression(left=ColumnNameLiteral(columnName=condition.columnName),
+		                                operator=condition.operator,
+		                                right=self.parse_condition_value(condition.columnValue))
+
+	def build_criteria_joint(self, condition: ConditionJoint) -> EntityCriteriaJoint:
+		return EntityCriteriaJoint(conjunction=condition.conjunction,
+		                           children=ArrayHelper(condition.children)
+		                           .map(lambda child: self.build_statement(child))
+		                           .to_list())
+
+	def parse_condition_value(self, condition_value: Any) -> Any:
+		if isinstance(condition_value, str):
+			if condition_value.startswith(LEFT_BRACE) and condition_value.startswith(RIGHT_BRACE):
+				variable_name = condition_value.removeprefix(LEFT_BRACE).removesuffix(RIGHT_BRACE)
+				variable_value = self.variables.get(variable_name)
+				parsed, value = is_date(variable_value, ask_all_date_formats())
+				if parsed:
+					return value
+				else:
+					return variable_value
+			else:
+				return condition_value
+		else:
+			return condition_value

watchmen_collector_kernel/service/data_capture.py

@@ -0,0 +1,60 @@
+from logging import getLogger
+from typing import Optional, Dict, Any, Tuple
+
+from watchmen_auth import PrincipalService
+from watchmen_collector_kernel.model import CollectorTableConfig
+from .extract_source import SourceTableExtractor
+from watchmen_collector_kernel.storage import get_collector_table_config_service
+from watchmen_storage import TransactionalStorageSPI, SnowflakeGenerator
+from watchmen_utilities import ArrayHelper
+from .extract_utils import build_criteria_by_join_key
+
+logger = getLogger(__name__)
+
+
+class DataCaptureService:
+
+	def __init__(self, storage: TransactionalStorageSPI,
+	             snowflake_generator: SnowflakeGenerator,
+	             principal_service: PrincipalService):
+		self.meta_storage = storage
+		self.snowflake_generator = snowflake_generator
+		self.principal_service = principal_service
+		self.collector_table_config_service = get_collector_table_config_service(self.meta_storage,
+		                                                                         self.snowflake_generator,
+		                                                                         self.principal_service)
+
+	def find_data_by_data_id(self, config: CollectorTableConfig, data_id: Dict) -> Optional[Dict[str, Any]]:
+		return SourceTableExtractor(config, self.principal_service).find_by_id(data_id)
+
+	def find_parent_node(self, config: CollectorTableConfig,
+	                     data_: Dict) -> Tuple[CollectorTableConfig, Optional[Dict[str, Any]]]:
+		if config.parentName:
+			parent_config = self.collector_table_config_service.find_by_name(config.parentName)
+			parent_data = SourceTableExtractor(parent_config, self.principal_service).find(
+				ArrayHelper(config.joinKeys).map(lambda join_key: build_criteria_by_join_key(join_key, data_)).to_list()
+			)
+			if len(parent_data) != 1:
+				raise RuntimeError(f'The data : {data_}, config_name: {config.name}, '
+				                   f'parent_config_name: {parent_config.name}, size: {len(parent_data)}')
+			return self.find_parent_node(parent_config, parent_data[0])
+		else:
+			return config, data_
+
+	def build_json(self,
+	               config: CollectorTableConfig,
+	               data: Dict):
+		child_configs = self.collector_table_config_service.find_by_parent_name(config.name)
+		if child_configs:
+			ArrayHelper(child_configs).map(lambda child_config: self.get_child_data(child_config, data))
+
+	def get_child_data(self, child_config: CollectorTableConfig, data_: Dict):
+		child_data = SourceTableExtractor(child_config, self.principal_service).find(
+			ArrayHelper(child_config.joinKeys).map(lambda join_key: build_criteria_by_join_key(join_key, data_, True)).to_list()
+		)
+		if child_data:
+			if child_config.isList:
+				data_[child_config.label] = child_data
+			else:
+				data_[child_config.label] = child_data[0]
+			ArrayHelper(child_data).each(lambda child: self.build_json(child_config, child))

watchmen_collector_kernel/service/extract_source.py

@@ -0,0 +1,71 @@
+from typing import Optional, List, Dict, Any
+
+from watchmen_auth import PrincipalService
+from .extract_utils import build_criteria_by_primary_key
+from watchmen_collector_kernel.model import CollectorTableConfig
+from watchmen_data_kernel.service import ask_topic_storage, ask_topic_data_service
+from watchmen_data_kernel.topic_schema import TopicSchema
+from watchmen_model.admin import Topic, TopicKind
+from watchmen_storage import EntityCriteria, EntityStraightColumn
+from watchmen_utilities import get_current_time_in_seconds, ArrayHelper
+
+
+class SourceTableExtractor:
+
+	def __init__(self, config: CollectorTableConfig, principal_service: PrincipalService):
+		self.config = config
+		self.principal_service = principal_service
+		self.topic = self.fake_extracted_table_to_topic(self.config)
+		self.storage = ask_topic_storage(self.topic, self.principal_service)
+		self.storage.register_topic(self.topic)
+		self.service = ask_topic_data_service(TopicSchema(self.topic), self.storage, principal_service)
+
+	# noinspection PyMethodMayBeStatic
+	def fake_topic_id(self, config_id: str) -> str:
+		return f'f-{config_id}'
+
+	def fake_extracted_table_to_topic(self, config: CollectorTableConfig) -> Topic:
+		#  Fake synonym topic to visit source table
+		topic = Topic(topicId=self.fake_topic_id(config.configId),
+		              name=config.tableName,
+		              dataSourceId=config.dataSourceId,
+		              kind=TopicKind.SYNONYM,
+		              tenantId=self.principal_service.tenantId
+		              )
+		topic_storage = ask_topic_storage(topic, self.principal_service)
+		factors = topic_storage.ask_synonym_factors(config.tableName)
+		topic.factors = factors
+		now = get_current_time_in_seconds()
+		topic.createdAt = now
+		topic.createdBy = self.principal_service.get_user_id()
+		topic.lastModifiedAt = now
+		topic.lastModifiedBy = self.principal_service.get_user_id()
+		return topic
+
+	def find_change_data(self, criteria: EntityCriteria) -> Optional[List[Dict[str, Any]]]:
+		return self.lower_key(self.service.find_straight_values(
+			criteria=criteria,
+			columns=ArrayHelper(self.config.primaryKey).map(
+				lambda column_name: EntityStraightColumn(columnName=column_name)
+			).to_list()
+		))
+
+	def find_by_id(self, data_id: Dict) -> Optional[Dict[str, Any]]:
+		results = self.service.find(build_criteria_by_primary_key(data_id))
+		if len(results) == 1:
+			return self.lower_key(results)[0]
+		elif len(results) == 0:
+			return None
+		else:
+			raise RuntimeError(f'too many results with {data_id} find')
+
+	def find(self, criteria: EntityCriteria) -> Optional[List[Dict[str, Any]]]:
+		return self.lower_key(self.service.find(criteria))
+
+	def exists(self, criteria: EntityCriteria) -> bool:
+		return self.service.exists(criteria)
+
+	# noinspection PyMethodMayBeStatic
+	def lower_key(self, data_: List) -> Optional[List[Dict]]:
+		return ArrayHelper(data_).map(
+			lambda row: {k.lower(): v for k, v in row.items()}).to_list()

watchmen_collector_kernel/service/extract_utils.py

@@ -0,0 +1,70 @@
+from datetime import datetime
+from logging import getLogger
+from typing import Dict, Any, List
+
+import numpy as np
+
+from watchmen_collector_kernel.model.collector_table_config import JoinKey
+from watchmen_storage import EntityCriteriaExpression, ColumnNameLiteral, EntityCriteriaStatement, EntityCriteria, \
+	EntityCriteriaOperator
+from watchmen_utilities import ArrayHelper
+
+logger = getLogger(__name__)
+
+
+def get_data_id(primary_key: List[str], data_: Dict[str, Any]) -> Dict:
+	data_id = {}
+
+	def set_data_id(column_name: str, data_dict: Dict):
+		data_id[column_name] = data_dict.get(column_name)
+
+	ArrayHelper(primary_key).each(lambda column_name: set_data_id(column_name, data_))
+	return data_id
+
+
+def build_data_id(primary_key: List[str], values: List) -> Dict:
+	data_id = {}
+
+	def set_data_id(column_name: str, index: int, data_list: List):
+		data_id[column_name] = data_list[index]
+
+	ArrayHelper(primary_key).each_with_index(lambda column_name, index: set_data_id(column_name, index, values))
+	return data_id
+
+
+def build_audit_column_criteria(audit_column_name: str, start_time: datetime, end_time: datetime) -> EntityCriteria:
+	return [
+		EntityCriteriaExpression(
+			left=ColumnNameLiteral(columnName=audit_column_name),
+			operator=EntityCriteriaOperator.GREATER_THAN_OR_EQUALS,
+			right=start_time),
+		EntityCriteriaExpression(
+			left=ColumnNameLiteral(columnName=audit_column_name),
+			operator=EntityCriteriaOperator.LESS_THAN_OR_EQUALS,
+			right=end_time),
+	]
+
+
+def build_criteria_by_primary_key(data_id: Dict) -> List[EntityCriteriaExpression]:
+	criteria = []
+	for key, value in data_id.items():
+		criteria.append(
+			EntityCriteriaExpression(left=ColumnNameLiteral(columnName=key), right=value)
+		)
+	return criteria
+
+
+def build_criteria_by_join_key(join_key: JoinKey, data: Dict, is_child: bool = False) -> EntityCriteriaStatement:
+	if is_child:
+		column_name = join_key.childKey
+		column_value = data.get(join_key.parentKey)
+	else:
+		column_name = join_key.parentKey
+		column_value = data.get(join_key.childKey)
+	return EntityCriteriaExpression(left=ColumnNameLiteral(columnName=column_name), right=column_value)
+
+
+def cal_array2d_diff(array_0: np.ndarray, array_1: np.ndarray) -> np.ndarray:
+	array_0_rows = array_0.view([('', array_0.dtype)] * array_0.shape[1])
+	array_1_rows = array_1.view([('', array_1.dtype)] * array_1.shape[1])
+	return np.setdiff1d(array_0_rows, array_1_rows).view(array_0.dtype).reshape(-1, array_0.shape[1])

watchmen_collector_kernel/service/lock_clean.py

@@ -0,0 +1,39 @@
+from datetime import datetime, timedelta
+from logging import getLogger
+from threading import Thread
+
+from time import sleep
+
+from watchmen_collector_kernel.storage import get_competitive_lock_service
+from watchmen_meta.common import ask_meta_storage
+
+
+class LockClean:
+
+	def __init__(self):
+		self.lock_service = get_competitive_lock_service(ask_meta_storage())
+		self.cleanInterval = 60
+
+	def run(self):
+		try:
+			while True:
+				self.clean_lock()
+				sleep(self.cleanInterval)
+		except Exception as e:
+			getLogger(__name__).error(e, exc_info=True, stack_info=True)
+			sleep(60)
+			self.restart()
+
+	def clean_lock(self):
+		query_time = datetime.now() - timedelta(minutes=120)
+		locks = self.lock_service.find_overtime_lock(query_time)
+		for lock in locks:
+			self.lock_service.delete_by_id(lock.lockId)
+
+	def restart(self):
+		Thread(target=LockClean.run, args=(self,), daemon=True).start()
+
+
+def init_lock_clean():
+	lock_clean = LockClean()
+	lock_clean.restart()

watchmen_collector_kernel/service/lock_helper.py

@@ -0,0 +1,28 @@
+from typing import Union
+
+from sqlalchemy.exc import IntegrityError
+
+from watchmen_collector_kernel.model import CompetitiveLock
+from watchmen_collector_kernel.storage.competitive_lock_service import CompetitiveLockService
+from watchmen_utilities import get_current_time_in_seconds
+
+
+def try_lock_nowait(lock_service: CompetitiveLockService, lock: CompetitiveLock) -> bool:
+	try:
+		lock_service.insert_one(lock)
+		return True
+	except IntegrityError:
+		return False
+
+
+def unlock(lock_service: CompetitiveLockService, lock: CompetitiveLock) -> bool:
+	lock_service.delete_by_id(lock.lockId)
+	return True
+
+
+def get_resource_lock(lock_id: int, resource_id: Union[str, int], tenant_id: str) -> CompetitiveLock:
+	return CompetitiveLock(
+		lockId=lock_id,
+		resourceId=resource_id,
+		registeredAt=get_current_time_in_seconds(),
+		tenantId=tenant_id)