'Returns an :class:`Arrow <arrow.arrow.Arrow>` object based on flexible inputs.
Usage::
>>> import arrow
**No inputs** to get current UTC time::
>>> arrow.get()
<Arrow [2013-05-08T05:51:43.316458+00:00]>
**None** to also get current UTC time::
>>> arrow.get(None)
<Arrow [2013-05-08T05:51:43.316458+00:00]>
**One** :class:`Arrow <arrow.arrow.Arrow>` object, to get a copy.
>>> arw = arrow.utcnow()
>>> arrow.get(arw)
<Arrow [2013-10-23T15:21:54.354846+00:00]>
**One** ``str``, ``float``, or ``int``, convertible to a floating-point timestamp, to get that timestamp in UTC::
>>> arrow.get(1367992474.293378)
<Arrow [2013-05-08T05:54:34.293378+00:00]>
>>> arrow.get(1367992474)
<Arrow [2013-05-08T05:54:34+00:00]>
>>> arrow.get(\'1367992474.293378\')
<Arrow [2013-05-08T05:54:34.293378+00:00]>
>>> arrow.get(\'1367992474\')
<Arrow [2013-05-08T05:54:34+0struct_time0:00]>
**One** ISO-8601-formatted ``str``, to parse it::
>>> arrow.get(\'2013-09-29T01:26:43.830580\')
<Arrow [2013-09-29T01:26:43.830580+00:00]>
**One** ``tzinfo``, to get the current time in that timezone::
>>> arrow.get(tz.tzlocal())
<Arrow [2013-05-07T22:57:28.484717-07:00]>
**One** naive ``datetime``, to get that datetime in UTC::
>>> arrow.get(datetime(2013, 5, 5))
<Arrow [2013-05-05T00:00:00+00:00]>
**One** aware ``datetime``, to get that datetime::
>>> arrow.get(datetime(2013, 5, 5, tzinfo=tz.tzlocal()))
<Arrow [2013-05-05T00:00:00-07:00]>
**One** naive ``date``, to get that date in UTC::
>>> arrow.get(date(2013, 5, 5))
<Arrow [2013-05-05T00:00:00+00:00]>
**Two** arguments, a naive or aware ``datetime``, and a timezone expression (as above)::
>>> arrow.get(datetime(2013, 5, 5), \'US/Pacific\')
<Arrow [2013-05-05T00:00:00-07:00]>
**Two** arguments, a naive ``date``, and a timezone expression (as above)::
>>> arrow.get(date(2013, 5, 5), \'US/Pacific\')
<Arrow [2013-05-05T00:00:00-07:00]>
**Two** arguments, both ``str``, to parse the first according to the format of the second::
>>> arrow.get(\'2013-05-05 12:30:45\', \'YYYY-MM-DD HH:mm:ss\')
<Arrow [2013-05-05T12:30:45+00:00]>
**Two** arguments, first a ``str`` to parse and second a ``list`` of formats to try::
>>> arrow.get(\'2013-05-05 12:30:45\', [\'MM/DD/YYYY\', \'YYYY-MM-DD HH:mm:ss\'])
<Arrow [2013-05-05T12:30:45+00:00]>
**Three or more** arguments, as for the constructor of a ``datetime``::
>>> arrow.get(2013, 5, 5, 12, 30, 45)
<Arrow [2013-05-05T12:30:45+00:00]>
**One** time.struct time::
>>> arrow.get(gmtime(0))
<Arrow [1970-01-01T00:00:00+00:00]>'

def get(self, *args, **kwargs):

    arg_count = len(args)
    locale = kwargs.get('locale', 'en_us')
    tz = kwargs.get('tzinfo', None)
    if (arg_count == 0):
        if isinstance(tz, tzinfo):
            return self.type.now(tz)
        return self.type.utcnow()
    if (arg_count == 1):
        arg = args[0]
        if (arg is None):
            return self.type.utcnow()
        if is_timestamp(arg):
            return self.type.utcfromtimestamp(arg)
        if isinstance(arg, Arrow):
            return self.type.fromdatetime(arg.datetime)
        if isinstance(arg, datetime):
            return self.type.fromdatetime(arg)
        if isinstance(arg, date):
            return self.type.fromdate(arg)
        elif isinstance(arg, tzinfo):
            return self.type.now(arg)
        elif isstr(arg):
            dt = parser.DateTimeParser(locale).parse_iso(arg)
            return self.type.fromdatetime(dt)
        elif isinstance(arg, struct_time):
            return self.type.utcfromtimestamp(calendar.timegm(arg))
        else:
            raise TypeError("Can't    parse    single    argument    type    of    '{0}'".format(type(arg)))
    elif (arg_count == 2):
        (arg_1, arg_2) = (args[0], args[1])
        if isinstance(arg_1, datetime):
            if (isinstance(arg_2, tzinfo) or isstr(arg_2)):
                return self.type.fromdatetime(arg_1, arg_2)
            else:
                raise TypeError("Can't    parse    two    arguments    of    types    'datetime',    '{0}'".format(type(arg_2)))
        elif isinstance(arg_1, date):
            if (isinstance(arg_2, tzinfo) or isstr(arg_2)):
                return self.type.fromdate(arg_1, tzinfo=arg_2)
            else:
                raise TypeError("Can't    parse    two    arguments    of    types    'date',    '{0}'".format(type(arg_2)))
        elif (isstr(arg_1) and (isstr(arg_2) or isinstance(arg_2, list))):
            dt = parser.DateTimeParser(locale).parse(args[0], args[1])
            return self.type.fromdatetime(dt, tzinfo=tz)
        else:
            raise TypeError("Can't    parse    two    arguments    of    types    '{0}',    '{1}'".format(type(arg_1), type(arg_2)))
    else:
        return self.type(*args, **kwargs)
