saucenao.files.filter.Filter.apply() - Code Metrics - Inspection of "[TASK] extract creation date and modified date che..." - DaRealFreak/saucenao - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (9117d2)

by Steffen

created 2018-01-30 14:44 UTC

saucenao.files.filter.Filter.apply() F

↳ Parent: Project

Complexity

Conditions

Size

Total Lines	60
Code Lines	34

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	34
dl	0
loc	60
rs	3.1212
c	0
b	0
f	0
cc	19
nop	3

How to fix Long Method Complexity

#!/usr/bin/python
# -*- coding: utf-8 -*-
import datetime
import os
import re
from pathlib import Path
from stat import ST_CTIME, ST_MTIME, ST_SIZE
from typing import Generator

from saucenao.files.constraint import Constraint


class Filter:
    """
    Filter to apply constraints for multiple metadata entries of the files.
    Obviously the files have to exist or they'll automatically get removed.
    Returns a generator object
    """

    _directory = None
    _file_system_objects = None

    def __init__(self, assert_is_folder=False, assert_is_file=False, creation_date=None, modified_date=None, name=None,
                 file_type=None, size=None):
        """Initializing function

        :type assert_is_folder: bool
        :type assert_is_file: bool
        :type creation_date: Constraint
        :type modified_date: Constraint
        :type name: Constraint
        :type file_type: Constraint
        :type size: Constraint
        """
        self._filter_assert_is_folder = assert_is_folder
        self._filter_assert_is_file = assert_is_file
        self._filter_creation_date = creation_date
        self._filter_modified_date = modified_date
        self._filter_name = name
        self._filter_file_type = file_type
        self._filter_file_size = size

    @property
    def file_system_objects(self):
        """Property for file system objects

        :return:
        """
        if self._file_system_objects is None:
            if self._directory:
                return os.listdir(self._directory)
            else:
                return []
        return self._file_system_objects

    @staticmethod
    def _get_timestamp_from_datestring(date_string):
        """Convert the given date string to timestamp

        :param date_string:
        :return:
        """
        if re.match('\d+.\d+.\d+ \d+:\d+:\d+', date_string):
            return datetime.datetime.strptime(date_string, "%d.%m.%Y %H:%M:%S").timestamp()
        elif re.match('\d+.\d+.\d+ \d+:\d+', date_string):
            return datetime.datetime.strptime(date_string, "%d.%m.%Y %H:%M").timestamp()
        elif re.match('\d+.\d+.\d+', date_string):
            return datetime.datetime.strptime(date_string, "%d.%m.%Y").timestamp()
        else:
            raise AttributeError("The date doesn't fit the format: d.m.Y[ H:M[:S]]")

    def apply(self, directory='', file_system_objects=None):
        """Apply the filter values to the given FSOs(File System Objects)

        :type directory: str
        :type file_system_objects: list|tuple|Generator
        :return:
        """
        self._directory = directory
        self._file_system_objects = file_system_objects

        for file_system_object in self.file_system_objects:
            abs_path = os.path.join(directory, file_system_object)

            # check if the FSO exists, else we can't access the metadata
            if not os.path.exists(abs_path):
                continue

            # check if the FSO is a file
            if self._filter_assert_is_file and not os.path.isfile(abs_path):
                continue

            # check if the FSO is a folder
            if self._filter_assert_is_folder and not os.path.isdir(abs_path):
                continue

            file_stats = os.stat(abs_path)

            # check if the FSO creation date matches the constraint
            if self._filter_creation_date and not self.apply_creation_date(file_stats):
                continue

            # check if the FSO modification date matches the constraint
            if self._filter_modified_date and not self.apply_modified_date(file_stats):
                continue

            # check if the FSO name matches the constraint
            if self._filter_name and not self._filter_name.cmp_func(file_system_object, self._filter_name.value):
                continue

            # check if the FSO suffix matches the constraint
            if self._filter_file_type and not self._filter_file_type.cmp_func(Path(abs_path).suffix,
                                                                              self._filter_file_type.value):
                continue

            # check if the FSO size matches the constraint
            if self._filter_file_size and not self._filter_file_size.cmp_func(file_stats[ST_SIZE],
                                                                              self._filter_file_size.value):
                continue

            yield file_system_object

    def apply_creation_date(self, file_stats):
        """Apply creation date option

        :param file_stats:
        :return:
        """
        creation_time = file_stats[ST_CTIME]
        expected_creation_time = self._get_timestamp_from_datestring(self._filter_creation_date.value)
        if self._filter_creation_date.cmp_func(creation_time, expected_creation_time):
            return True
        else:
            return False

    def apply_modified_date(self, file_stats):
        """Apply modified date option

        :param file_stats:
        :return:
        """
        modified_time = file_stats[ST_MTIME]
        expected_modified_time = self._get_timestamp_from_datestring(self._filter_modified_date.value)
        if self._filter_modified_date.cmp_func(modified_time, expected_modified_time):
            return True
        else:
            return False


1			#!/usr/bin/python
2			# -- coding: utf-8 --
3			import datetime
4			import os
5			import re
6			from pathlib import Path
7			from stat import ST_CTIME, ST_MTIME, ST_SIZE
8			from typing import Generator
9
10			from saucenao.files.constraint import Constraint
11
12
13			class Filter:
14			"""
15			Filter to apply constraints for multiple metadata entries of the files.
16			Obviously the files have to exist or they'll automatically get removed.
17			Returns a generator object
18			"""
19
20			_directory = None
21			_file_system_objects = None
22
23			def __init__(self, assert_is_folder=False, assert_is_file=False, creation_date=None, modified_date=None, name=None,
24			file_type=None, size=None):
25			"""Initializing function
26
27			:type assert_is_folder: bool
28			:type assert_is_file: bool
29			:type creation_date: Constraint
30			:type modified_date: Constraint
31			:type name: Constraint
32			:type file_type: Constraint
33			:type size: Constraint
34			"""
35			self._filter_assert_is_folder = assert_is_folder
36			self._filter_assert_is_file = assert_is_file
37			self._filter_creation_date = creation_date
38			self._filter_modified_date = modified_date
39			self._filter_name = name
40			self._filter_file_type = file_type
41			self._filter_file_size = size
42
43			@property
44			def file_system_objects(self):
45			"""Property for file system objects
46
47			:return:
48			"""
49			if self._file_system_objects is None:
50			if self._directory:
51			return os.listdir(self._directory)
52			else:
53			return []
54			return self._file_system_objects
55
56			@staticmethod
57			def _get_timestamp_from_datestring(date_string):
58			"""Convert the given date string to timestamp
59
60			:param date_string:
61			:return:
62			"""
63			if re.match('\d+.\d+.\d+ \d+:\d+:\d+', date_string):
64			return datetime.datetime.strptime(date_string, "%d.%m.%Y %H:%M:%S").timestamp()
65			elif re.match('\d+.\d+.\d+ \d+:\d+', date_string):
66			return datetime.datetime.strptime(date_string, "%d.%m.%Y %H:%M").timestamp()
67			elif re.match('\d+.\d+.\d+', date_string):
68			return datetime.datetime.strptime(date_string, "%d.%m.%Y").timestamp()
69			else:
70			raise AttributeError("The date doesn't fit the format: d.m.Y[ H:M[:S]]")
71
72			def apply(self, directory='', file_system_objects=None):
73			"""Apply the filter values to the given FSOs(File System Objects)
74
75			:type directory: str
76			:type file_system_objects: list\|tuple\|Generator
77			:return:
78			"""
79			self._directory = directory
80			self._file_system_objects = file_system_objects
81
82			for file_system_object in self.file_system_objects:
83			abs_path = os.path.join(directory, file_system_object)
84
85			# check if the FSO exists, else we can't access the metadata
86			if not os.path.exists(abs_path):
87			continue
88
89			# check if the FSO is a file
90			if self._filter_assert_is_file and not os.path.isfile(abs_path):
91			continue
92
93			# check if the FSO is a folder
94			if self._filter_assert_is_folder and not os.path.isdir(abs_path):
95			continue
96
97			file_stats = os.stat(abs_path)
98
99			# check if the FSO creation date matches the constraint
100			if self._filter_creation_date and not self.apply_creation_date(file_stats):
101			continue
102
103			# check if the FSO modification date matches the constraint
104			if self._filter_modified_date and not self.apply_modified_date(file_stats):
105			continue
106
107			# check if the FSO name matches the constraint
108			if self._filter_name and not self._filter_name.cmp_func(file_system_object, self._filter_name.value):
109			continue
110
111			# check if the FSO suffix matches the constraint
112			if self._filter_file_type and not self._filter_file_type.cmp_func(Path(abs_path).suffix,
113			self._filter_file_type.value):
114			continue
115
116			# check if the FSO size matches the constraint
117			if self._filter_file_size and not self._filter_file_size.cmp_func(file_stats[ST_SIZE],
118			self._filter_file_size.value):
119			continue
120
121			yield file_system_object
122
123			def apply_creation_date(self, file_stats):
124			"""Apply creation date option
125
126			:param file_stats:
127			:return:
128			"""
129			creation_time = file_stats[ST_CTIME]
130			expected_creation_time = self._get_timestamp_from_datestring(self._filter_creation_date.value)
131			if self._filter_creation_date.cmp_func(creation_time, expected_creation_time):
132			return True
133			else:
134			return False
135
136			def apply_modified_date(self, file_stats):
137			"""Apply modified date option
138
139			:param file_stats:
140			:return:
141			"""
142			modified_time = file_stats[ST_MTIME]
143			expected_modified_time = self._get_timestamp_from_datestring(self._filter_modified_date.value)
144			if self._filter_modified_date.cmp_func(modified_time, expected_modified_time):
145			return True
146			else:
147			return False
148

DaRealFreak / saucenao

Branch — master (9117d2)

saucenao.files.filter.Filter.apply() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like