Coverage for archdocs/features/redis/parser.py: 100%

17 statements  

« prev     ^ index     » next       coverage.py v7.15.3, created at 2026-08-03 00:00 +0000

1import re as py_re 

2import types 

3import typing 

4 

5from archdocs import prefilter, settings 

6from archdocs.features.redis.const import RedisFeatures 

7 

8 

9_REDIS_IMPORT_PATTERN: typing.Final = py_re.compile( 

10 r"\b(?:from\s+redis\b|import\s+redis\b)", 

11 flags=settings.TYPICAL_RE_FLAGS, 

12) 

13_ASYNC_REDIS_PATTERN: typing.Final = py_re.compile( 

14 r"\b(?:from\s+redis\.asyncio\b|import\s+redis\.asyncio\b)", 

15 flags=settings.TYPICAL_RE_FLAGS, 

16) 

17_REDIS_CONNECTION_PATTERNS: typing.Final = types.MappingProxyType( 

18 { 

19 "plain": py_re.compile(r"\b(?:redis\.|from\s+redis\s+import\s+).*\bRedis\b", flags=settings.TYPICAL_RE_FLAGS), 

20 "sentinel": py_re.compile( 

21 r"\b(?:redis\.sentinel\.|from\s+redis(?:\.sentinel)?\s+import\s+).*\bSentinel\b", 

22 flags=settings.TYPICAL_RE_FLAGS, 

23 ), 

24 "cluster": py_re.compile( 

25 r"\b(?:redis\.cluster\.|from\s+redis(?:\.cluster)?\s+import\s+).*\bRedisCluster\b", 

26 flags=settings.TYPICAL_RE_FLAGS, 

27 ), 

28 }, 

29) 

30_REDIS_RETRY_PATTERN: typing.Final = py_re.compile( 

31 r"\bredis\.Retry\s*\(", 

32 flags=settings.TYPICAL_RE_FLAGS, 

33) 

34_EMPTY_FEATURES: typing.Final = RedisFeatures( 

35 cluster_or_sentinel=False, 

36 connection_type=None, 

37 async_used=False, 

38 retry_used=False, 

39) 

40 

41 

42def find_redis_features(raw_source: str) -> RedisFeatures: 

43 if not prefilter.contains_any_literal(raw_source.lower(), ("redis",)): 

44 return _EMPTY_FEATURES 

45 if not _REDIS_IMPORT_PATTERN.search(raw_source): 

46 return _EMPTY_FEATURES 

47 connection_type: typing.Final = next( 

48 (one_type_name for one_type_name, pattern in _REDIS_CONNECTION_PATTERNS.items() if pattern.search(raw_source)), 

49 None, 

50 ) 

51 return RedisFeatures( 

52 connection_type=connection_type, 

53 cluster_or_sentinel=connection_type in ("sentinel", "cluster"), 

54 async_used=bool(_ASYNC_REDIS_PATTERN.search(raw_source)), 

55 retry_used=bool(_REDIS_RETRY_PATTERN.search(raw_source)), 

56 )