Access the monthly

        :returns: twilio.rest.api.v2010.account.usage.record.monthly.MonthlyList
        :rtype: twilio.rest.api.v2010.account.usage.record.monthly.MonthlyList
493623
def monthly(self):
        
        if self._monthly is None:
            self._monthly = MonthlyList(self._version, account_sid=self._solution['account_sid'], )
        return self._monthly
1011829
def accounts(self):
        
        if self._accounts is None:
            from twilio.rest.accounts import Accounts
            self._accounts = Accounts(self)
        return self._accounts
82051
def _get_usage(self, account_number, number):
        
        # Prepare data
        data = {"ctn": number,
                "language": "en-US",
                "accountNumber": account_number}
        # Http request
        try:
            raw_res = yield from self._session.post(USAGE_URL,
                                                    data=data,
                                                    headers=self._headers,
                                                    timeout=self._timeout)
        except OSError:
            raise PyFidoError("Can not get usage")
        # Load answer as json
        try:
            output = yield from raw_res.json()
        except (OSError, ValueError):
            raise PyFidoError("Can not get usage as json")
        # Format data
        ret_data = {}
        for data_name, keys in DATA_MAP.items():
            key, subkey = keys
            for data in output.get(key)[0].get('wirelessUsageSummaryInfoList'):
                if data.get('usageSummaryType') == subkey:
                    # Prepare keys:
                    used_key = "{}_used".format(data_name)
                    remaining_key = "{}_remaining".format(data_name)
                    limit_key = "{}_limit".format(data_name)
                    # Get values
                    ret_data[used_key] = data.get('used', 0.0)
                    if data.get('remaining') >= 0:
                        ret_data[remaining_key] = data.get('remaining')
                    else:
                        ret_data[remaining_key] = None
                    if data.get('total') >= 0:
                        ret_data[limit_key] = data.get('total')
                    else:
                        ret_data[limit_key] = None

        return ret_data
873783
def get_my_choices_users():
    

    user_list = User.objects.order_by('date_joined')
    user_tuple = []
    counter = 1
    for user in user_list:
        user_tuple.append((counter, user))
        counter = counter + 1
    return user_tuple
613701
def display_monthly_returns(self):
        
        data = [['Year', 'Jan', 'Feb', 'Mar', 'Apr', 'May',
                 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'YTD']]
        for k in self.return_table.index:
            r = self.return_table.loc[k].values
            data.append([k] + [fmtpn(x) for x in r])
        print(tabulate(data, headers='firstrow'))
1246011
def get_month_list(to_date, from_date):
    

    num_months = get_months_apart(to_date, from_date)
    month_offset = from_date.month
    month_list = []
    for month in range(month_offset-1, month_offset+num_months):
        year = from_date.year+(month/12)
        real_month = (month % 12) + 1
        month_list.append((year, real_month))

    return month_list
1279435
def consumed_in_month(self):
        
        month_end = core_utils.month_end(datetime.date(self.price_estimate.year, self.price_estimate.month, 1))
        return self._get_consumed(month_end)
656519
def recordings(self):
        
        if self._recordings is None:
            self._recordings = RecordingList(self)
        return self._recordings
559081
def get_account(self):
        '''
        
        '''
        try:
            listing = self.conn.get_account()
            return listing
        except Exception as exc:
            log.error('There was an error::')
            if hasattr(exc, 'code') and hasattr(exc, 'msg'):
                log.error('    Code: %s: %s', exc.code, exc.msg)
            log.error('    Content: \n%s', getattr(exc, 'read', lambda: six.text_type(exc))())
            return False
234
def access_storage_list(**kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('access:storage:list', **{
        'storage': ctx.repo.create_secure_service('storage'),
    })
706108
def month_roll(self):
        
        if self._prefix.endswith('S'):
            # MonthBegin
            roll_func = self.m_offset.rollback
        else:
            # MonthEnd
            roll_func = self.m_offset.rollforward
        return roll_func
1154210
def usage(self):
        
        if self._usage is None:
            self._usage = UsageList(self._version, sim_sid=self._solution['sid'], )
        return self._usage
432756
def params(self):
        
        params = {}
        params["access_token"] = self.access_token
        params["account_id"] = self.account_id
        return params
648965
def group_by_month(self):
        
        data_by_month = OrderedDict()
        for d in xrange(1, 13):
            data_by_month[d] = []
        for v, dt in zip(self._values, self.datetimes):
            data_by_month[dt.month].append(v)
        return data_by_month
772968
def records(self):
        
        return [self._records[i] for i in range(len(self._records))]
905984
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return SyncListPermissionInstance(
            self._version,
            payload,
            service_sid=self._solution['service_sid'],
            list_sid=self._solution['list_sid'],
            identity=self._solution['identity'],
        )
1087672
def filter_by_months(self, months):
        
        _filt_values = []
        _filt_datetimes = []
        for i, d in enumerate(self.datetimes):
            if d in months:
                _filt_datetimes.append(d)
                _filt_values.append(self._values[i])
        _filt_header = self.header.duplicate()
        return MonthlyCollection(_filt_header, _filt_values, _filt_datetimes)