buildtimetrend.split_datetime() - Code Metrics - Inspection of "use isinstance to check if it is a datetime instan..." - buildtimetrend/python-lib - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1a2e8a...8f6c6f )

by Dieter

created 2016-03-22 18:13 UTC

buildtimetrend.split_datetime() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	3
dl	0
loc	51
rs	9.4109

How to fix Long Method

# vim: set expandtab sw=4 ts=4:
"""
Collection of supporting functions.

Copyright (C) 2014-2016 Dieter Adriaenssens <[email protected]>

This file is part of buildtimetrend/python-lib
<https://github.com/buildtimetrend/python-lib/>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""

from __future__ import division
from builtins import str
from six import string_types
import os
from buildtimetrend import logger
from datetime import datetime
from dateutil.parser import parse
from dateutil.tz import tzutc
from decimal import Decimal
from decimal import getcontext
from numbers import Number


def format_timestamp(timestamp):
    """
    Format a datetime timestamp (UTC) to ISO format (YYYY-MM-DDTHH:MM:SS).

    Parameters :
    - timestamp : timestamp, seconds since epoch
    """
    timestamp_datetime = datetime.utcfromtimestamp(timestamp)
    return timestamp_datetime.isoformat()


def split_timestamp(timestamp):
    """
    Split a timestamp in seperate components.

    Split a timestamp (expressed in seconds since epoch)
    in all seperate components :
      year, month, day of month, day of week,
      hour (12 and 24 hour), minute, second

    Parameters :
    - timestamp : timestamp, seconds since epoch
    """
    if not isinstance(timestamp, Number):
        raise TypeError(
            "param timestamp should be a number {0!s}".format(type(timestamp))
        )

    ts_seconds = int(timestamp)
    ts_microseconds = int((timestamp - ts_seconds) * 1000000)
    dt_utc = datetime.utcfromtimestamp(ts_seconds).replace(
        tzinfo=tzutc(), microsecond=ts_microseconds
    )
    return split_datetime(dt_utc)


def split_isotimestamp(isotimestamp):
    """
    Split a ISO formatted timestamp in seperate components.

    Split a timestamp (in ISO format)
    in all seperate components :
      year, month, day of month, day of week,
      hour (12 and 24 hour), minute, second

    Parameters :
    - isotimestamp : timestamp in ISO format YYYY-MM-DDTHH:MM:SS
    """
    if is_string(isotimestamp, "isotimestamp"):
        # use dateutil.parser.parse to parse the timestamp
        return split_datetime(parse(isotimestamp, tzinfos={"UTC": +0}))


def split_datetime(timestamp_datetime):
    """
    Split a datetime timestamp in seperate components.

    Split a timestamp (is a datetime class instance)
    in all seperate components :
      year, month, day of month, day of week,
      hour (12 and 24 hour), minute, second

    Parameters :

    - timestamp_datetime : timestamp in datetime class format
    """
    if not isinstance(timestamp_datetime, datetime):
        raise TypeError(
            "param {0!s} should be a datetime instance".format(
                'timestamp_datetime'
            )
        )

    timestamp_dict = {}
    timestamp_dict["isotimestamp"] = timestamp_datetime.isoformat()

    # epoch = 1 Jan 1970
    epoch = datetime.utcfromtimestamp(0)
    # add timezone info to epoch if timestamp is timezone aware
    if timestamp_datetime.tzname() is not None:
        epoch = datetime.utcfromtimestamp(0).replace(tzinfo=tzutc())

    # seconds since epoch
    timestamp_dict["timestamp_seconds"] = \
        (timestamp_datetime - epoch).total_seconds()

    timestamp_dict["year"] = timestamp_datetime.strftime("%Y")
    timestamp_dict["month"] = timestamp_datetime.strftime("%m")
    timestamp_dict["month_short_en"] = timestamp_datetime.strftime("%b")
    timestamp_dict["month_full_en"] = timestamp_datetime.strftime("%B")
    timestamp_dict["day_of_month"] = timestamp_datetime.strftime("%d")
    timestamp_dict["day_of_week"] = timestamp_datetime.strftime("%w")
    timestamp_dict["day_of_week_short_en"] = timestamp_datetime.strftime("%a")
    timestamp_dict["day_of_week_full_en"] = timestamp_datetime.strftime("%A")
    timestamp_dict["hour_12"] = timestamp_datetime.strftime("%I")
    timestamp_dict["hour_ampm"] = timestamp_datetime.strftime("%p")
    timestamp_dict["hour_24"] = timestamp_datetime.strftime("%H")
    timestamp_dict["minute"] = timestamp_datetime.strftime("%M")
    timestamp_dict["second"] = timestamp_datetime.strftime("%S")
    timestamp_dict["microsecond"] = timestamp_datetime.strftime("%f")
    timestamp_dict["timezone"] = timestamp_datetime.strftime("%Z")
    timestamp_dict["timezone_offset"] = timestamp_datetime.strftime("%z")

    return timestamp_dict


def nano2sec(time):
    """
    Convert time from nanoseconds to seconds.

    Parameters:
    - time : time in nanoseconds
    """
    getcontext().prec = 20
    return Decimal(int(time)) / Decimal(1000000000)


def check_file(filename):
    """
    Check if a file exists.

    Parameters :
    - filename : file to be checked
    Return false if file doesn't exist, true if it exists.
    """
    # load timestamps file
    if not os.path.isfile(filename):
        logger.critical('File doesn\'t exist : %s', filename)
        return False

    return True


def file_is_newer(path1, path2):
    """
    Check if a file is newer than another file.

    Parameters :
    - path1 : path of first file
    - path2 : ipath of second file
    Return true if the first file is newer than the second one,
    return false if it is older, or if any of the files doesn't exist.
    """
    # check if files exist
    if not check_file(path1) or not check_file(path2):
        return False

    mtime1 = os.path.getmtime(path1)
    mtime2 = os.path.getmtime(path2)

    # check modification times
    return (mtime1 - mtime2) > 0


def is_dict(param_dict):
    """
    Return true if a parameter is a dictionary.

    Parameters :
    - param_dict: parameter that should be a dictonary
    Return true if parameter is a dictionary.
    """
    return param_dict is not None and type(param_dict) is dict


def check_dict(param_dict, name=None, key_list=None):
    """
    Check if a parameter is a dictionary.

    Returns True if it is a dictionary, false if it isn't,
    or if parameter 'name' is specified,
    an Error is raised with the name in the message.

    If key_list is defined,
    true is returned if the keys in key_list exits in the dictionary,
    false if they don't all exist.

    Parameters :
    - param_dict: parameter that should be a dictonary
    - name: name of the parameter
    - key_list: list of keys that should be present in the dict
    Return true if parameter is a dictionary, throws error when it isn't
    """
    if not is_dict(param_dict):
        if name is None:
            return False
        else:
            raise TypeError("param {0!s} should be a dictionary".format(name))

    # check if key_list is defined
    if key_list is None:
        # key_list is not defined, no need to check keys
        return True
    else:
        # check if dictionary contains all keys in key_list
        return keys_in_dict(param_dict, key_list)


def keys_in_dict(param_dict, key_list):
    """
    Check if a list of keys exist in a dictionary.

    Parameters :
    - param_dict: dictonary that should contain the keys
    - key_list: key or list of keys that should be present in the dict
    Return true if all keys were found in the dictionary
    """
    if isinstance(key_list, (string_types, int)):
        return key_list in param_dict
    elif not is_list(key_list):
        return False

    for key in key_list:
        if key not in param_dict:
            return False

    return True


def is_list(param_list, name=None):
    """
    Check if a parameter is a list.

    Returns True if parameter is a list, false if it isn't,
    or if parameter 'name' is specified,
    an Error is raised with the name of the parameter in the message.

    Parameters :
    - param_list: parameter that should be a list
    - name: name of the parameter
    """
    if param_list is None or type(param_list) is not list:
        if name is None:
            return False
        else:
            raise TypeError("param {0!s} should be a list".format(name))

    return True


def is_string(param, name=None):
    """
    Check if a parameter is a string.

    Returns True if parameter is a string, false if it isn't,
    If parameter 'name' is specified,
    an Error is raised with the name of the parameter in the message.

    Parameters :
    - param: parameter that should be a string
    - name: name of the parameter
    """
    if param is None or not isinstance(param, string_types):
        if name is None:
            return False
        else:
            raise TypeError("param {0!s} should be a string".format(name))

    return True


def check_num_string(num_string, name):
    """
    Check if a parameter is an integer or numerical string.

    Parameters :
    - num_string: parameter that should be a numerical string
    - name: name of the parameter
    Return integer of numerical string, throws error when it isn't
    """
    if num_string is None or not isinstance(num_string, (string_types, int)):
        err_msg = "param {0!s} should be a numerical string or an integer"
        raise TypeError(err_msg.format(name))

    return int(num_string)


def get_repo_slug(repo_owner=None, repo_name=None):
    """
    Return repo slug.

    This function concatenates repo_owner and repo_name,
    fe. buildtimetrend/service

    Parameters :
    - repo_owner : name of the Github repo owner, fe. `buildtimetrend`
    - repo_name : name of the Github repo, fe. `service`
    """
    if repo_owner is not None and repo_name is not None:
        return "{0!s}/{1!s}".format(str(repo_owner), str(repo_name))
    else:
        return None


1			# vim: set expandtab sw=4 ts=4:
2			"""
3			Collection of supporting functions.
4
5			Copyright (C) 2014-2016 Dieter Adriaenssens <[email protected]>
6
7			This file is part of buildtimetrend/python-lib
8			<https://github.com/buildtimetrend/python-lib/>
9
10			This program is free software: you can redistribute it and/or modify
11			it under the terms of the GNU Affero General Public License as published by
12			the Free Software Foundation, either version 3 of the License, or
13			any later version.
14
15			This program is distributed in the hope that it will be useful,
16			but WITHOUT ANY WARRANTY; without even the implied warranty of
17			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18			GNU Affero General Public License for more details.
19
20			You should have received a copy of the GNU Affero General Public License
21			along with this program. If not, see <http://www.gnu.org/licenses/>.
22			"""
23
24			from __future__ import division
25			from builtins import str
26			from six import string_types
27			import os
28			from buildtimetrend import logger
29			from datetime import datetime
30			from dateutil.parser import parse
31			from dateutil.tz import tzutc
32			from decimal import Decimal
33			from decimal import getcontext
34			from numbers import Number
35
36
37			def format_timestamp(timestamp):
38			"""
39			Format a datetime timestamp (UTC) to ISO format (YYYY-MM-DDTHH:MM:SS).
40
41			Parameters :
42			- timestamp : timestamp, seconds since epoch
43			"""
44			timestamp_datetime = datetime.utcfromtimestamp(timestamp)
45			return timestamp_datetime.isoformat()
46
47
48			def split_timestamp(timestamp):
49			"""
50			Split a timestamp in seperate components.
51
52			Split a timestamp (expressed in seconds since epoch)
53			in all seperate components :
54			year, month, day of month, day of week,
55			hour (12 and 24 hour), minute, second
56
57			Parameters :
58			- timestamp : timestamp, seconds since epoch
59			"""
60			if not isinstance(timestamp, Number):
61			raise TypeError(
62			"param timestamp should be a number {0!s}".format(type(timestamp))
63			)
64
65			ts_seconds = int(timestamp)
66			ts_microseconds = int((timestamp - ts_seconds) * 1000000)
67			dt_utc = datetime.utcfromtimestamp(ts_seconds).replace(
68			tzinfo=tzutc(), microsecond=ts_microseconds
69			)
70			return split_datetime(dt_utc)
71
72
73			def split_isotimestamp(isotimestamp):
74			"""
75			Split a ISO formatted timestamp in seperate components.
76
77			Split a timestamp (in ISO format)
78			in all seperate components :
79			year, month, day of month, day of week,
80			hour (12 and 24 hour), minute, second
81
82			Parameters :
83			- isotimestamp : timestamp in ISO format YYYY-MM-DDTHH:MM:SS
84			"""
85			if is_string(isotimestamp, "isotimestamp"):
86			# use dateutil.parser.parse to parse the timestamp
87			return split_datetime(parse(isotimestamp, tzinfos={"UTC": +0}))
88
89
90			def split_datetime(timestamp_datetime):
91			"""
92			Split a datetime timestamp in seperate components.
93
94			Split a timestamp (is a datetime class instance)
95			in all seperate components :
96			year, month, day of month, day of week,
97			hour (12 and 24 hour), minute, second
98
99			Parameters :
100
101			- timestamp_datetime : timestamp in datetime class format
102			"""
103			if not isinstance(timestamp_datetime, datetime):
104			raise TypeError(
105			"param {0!s} should be a datetime instance".format(
106			'timestamp_datetime'
107			)
108			)
109
110			timestamp_dict = {}
111			timestamp_dict["isotimestamp"] = timestamp_datetime.isoformat()
112
113			# epoch = 1 Jan 1970
114			epoch = datetime.utcfromtimestamp(0)
115			# add timezone info to epoch if timestamp is timezone aware
116			if timestamp_datetime.tzname() is not None:
117			epoch = datetime.utcfromtimestamp(0).replace(tzinfo=tzutc())
118
119			# seconds since epoch
120			timestamp_dict["timestamp_seconds"] = \
121			(timestamp_datetime - epoch).total_seconds()
122
123			timestamp_dict["year"] = timestamp_datetime.strftime("%Y")
124			timestamp_dict["month"] = timestamp_datetime.strftime("%m")
125			timestamp_dict["month_short_en"] = timestamp_datetime.strftime("%b")
126			timestamp_dict["month_full_en"] = timestamp_datetime.strftime("%B")
127			timestamp_dict["day_of_month"] = timestamp_datetime.strftime("%d")
128			timestamp_dict["day_of_week"] = timestamp_datetime.strftime("%w")
129			timestamp_dict["day_of_week_short_en"] = timestamp_datetime.strftime("%a")
130			timestamp_dict["day_of_week_full_en"] = timestamp_datetime.strftime("%A")
131			timestamp_dict["hour_12"] = timestamp_datetime.strftime("%I")
132			timestamp_dict["hour_ampm"] = timestamp_datetime.strftime("%p")
133			timestamp_dict["hour_24"] = timestamp_datetime.strftime("%H")
134			timestamp_dict["minute"] = timestamp_datetime.strftime("%M")
135			timestamp_dict["second"] = timestamp_datetime.strftime("%S")
136			timestamp_dict["microsecond"] = timestamp_datetime.strftime("%f")
137			timestamp_dict["timezone"] = timestamp_datetime.strftime("%Z")
138			timestamp_dict["timezone_offset"] = timestamp_datetime.strftime("%z")
139
140			return timestamp_dict
141
142
143			def nano2sec(time):
144			"""
145			Convert time from nanoseconds to seconds.
146
147			Parameters:
148			- time : time in nanoseconds
149			"""
150			getcontext().prec = 20
151			return Decimal(int(time)) / Decimal(1000000000)
152
153
154			def check_file(filename):
155			"""
156			Check if a file exists.
157
158			Parameters :
159			- filename : file to be checked
160			Return false if file doesn't exist, true if it exists.
161			"""
162			# load timestamps file
163			if not os.path.isfile(filename):
164			logger.critical('File doesn\'t exist : %s', filename)
165			return False
166
167			return True
168
169
170			def file_is_newer(path1, path2):
171			"""
172			Check if a file is newer than another file.
173
174			Parameters :
175			- path1 : path of first file
176			- path2 : ipath of second file
177			Return true if the first file is newer than the second one,
178			return false if it is older, or if any of the files doesn't exist.
179			"""
180			# check if files exist
181			if not check_file(path1) or not check_file(path2):
182			return False
183
184			mtime1 = os.path.getmtime(path1)
185			mtime2 = os.path.getmtime(path2)
186
187			# check modification times
188			return (mtime1 - mtime2) > 0
189
190
191			def is_dict(param_dict):
192			"""
193			Return true if a parameter is a dictionary.
194
195			Parameters :
196			- param_dict: parameter that should be a dictonary
197			Return true if parameter is a dictionary.
198			"""
199			return param_dict is not None and type(param_dict) is dict
200
201
202			def check_dict(param_dict, name=None, key_list=None):
203			"""
204			Check if a parameter is a dictionary.
205
206			Returns True if it is a dictionary, false if it isn't,
207			or if parameter 'name' is specified,
208			an Error is raised with the name in the message.
209
210			If key_list is defined,
211			true is returned if the keys in key_list exits in the dictionary,
212			false if they don't all exist.
213
214			Parameters :
215			- param_dict: parameter that should be a dictonary
216			- name: name of the parameter
217			- key_list: list of keys that should be present in the dict
218			Return true if parameter is a dictionary, throws error when it isn't
219			"""
220			if not is_dict(param_dict):
221			if name is None:
222			return False
223			else:
224			raise TypeError("param {0!s} should be a dictionary".format(name))
225
226			# check if key_list is defined
227			if key_list is None:
228			# key_list is not defined, no need to check keys
229			return True
230			else:
231			# check if dictionary contains all keys in key_list
232			return keys_in_dict(param_dict, key_list)
233
234
235			def keys_in_dict(param_dict, key_list):
236			"""
237			Check if a list of keys exist in a dictionary.
238
239			Parameters :
240			- param_dict: dictonary that should contain the keys
241			- key_list: key or list of keys that should be present in the dict
242			Return true if all keys were found in the dictionary
243			"""
244			if isinstance(key_list, (string_types, int)):
245			return key_list in param_dict
246			elif not is_list(key_list):
247			return False
248
249			for key in key_list:
250			if key not in param_dict:
251			return False
252
253			return True
254
255
256			def is_list(param_list, name=None):
257			"""
258			Check if a parameter is a list.
259
260			Returns True if parameter is a list, false if it isn't,
261			or if parameter 'name' is specified,
262			an Error is raised with the name of the parameter in the message.
263
264			Parameters :
265			- param_list: parameter that should be a list
266			- name: name of the parameter
267			"""
268			if param_list is None or type(param_list) is not list:
269			if name is None:
270			return False
271			else:
272			raise TypeError("param {0!s} should be a list".format(name))
273
274			return True
275
276
277			def is_string(param, name=None):
278			"""
279			Check if a parameter is a string.
280
281			Returns True if parameter is a string, false if it isn't,
282			If parameter 'name' is specified,
283			an Error is raised with the name of the parameter in the message.
284
285			Parameters :
286			- param: parameter that should be a string
287			- name: name of the parameter
288			"""
289			if param is None or not isinstance(param, string_types):
290			if name is None:
291			return False
292			else:
293			raise TypeError("param {0!s} should be a string".format(name))
294
295			return True
296
297
298			def check_num_string(num_string, name):
299			"""
300			Check if a parameter is an integer or numerical string.
301
302			Parameters :
303			- num_string: parameter that should be a numerical string
304			- name: name of the parameter
305			Return integer of numerical string, throws error when it isn't
306			"""
307			if num_string is None or not isinstance(num_string, (string_types, int)):
308			err_msg = "param {0!s} should be a numerical string or an integer"
309			raise TypeError(err_msg.format(name))
310
311			return int(num_string)
312
313
314			def get_repo_slug(repo_owner=None, repo_name=None):
315			"""
316			Return repo slug.
317
318			This function concatenates repo_owner and repo_name,
319			fe. buildtimetrend/service
320
321			Parameters :
322			- repo_owner : name of the Github repo owner, fe. `buildtimetrend`
323			- repo_name : name of the Github repo, fe. `service`
324			"""
325			if repo_owner is not None and repo_name is not None:
326			return "{0!s}/{1!s}".format(str(repo_owner), str(repo_name))
327			else:
328			return None
329

buildtimetrend / python-lib

Push — master ( 1a2e8a...8f6c6f )

buildtimetrend.split_datetime() A

Complexity

Size

Duplication

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like