Exemplo n.º 1
0
 def log_time(self, delta=None, billable=True, project=None, start=None,
              end=None, status=None, pause=0, activity=None, user=None):
     if not user:
         user = self.user
     if delta and not end:
         hours, minutes = delta
     else:
         hours = 4
         minutes = 0
     if not start:
         start = timezone.now() - relativedelta(hour=0)
         # In case the default would fall off the end of the billing period
         if start.day >= 28:
             start -= relativedelta(days=1)
     if not end:
         end = start + relativedelta(hours=hours, minutes=minutes)
     data = {'user': user,
             'start_time': start,
             'end_time': end,
             'seconds_paused': pause,
             }
     if project:
         data['project'] = project
     else:
         data['project'] = factories.BillableProject()
     if activity:
         data['activity'] = activity
     else:
         if billable:
             data['activity'] = self.devl_activity
         else:
             data['activity'] = self.activity
     if status:
         data['status'] = status
     return factories.Entry(**data)
Exemplo n.º 2
0
 def testFindEntries(self):
     """
     Given a list of users and a starting point, entries should generate a
     list of all entries for each user from that time until now.
     """
     start = check_entries.Command().find_start()
     if start.day == 1:
         start += relativedelta(days=1)
     all_users = check_entries.Command().find_users()
     entries = check_entries.Command().find_entries(all_users, start)
     # Determine the number of days checked
     today = timezone.now() - \
         relativedelta(hour=0, minute=0, second=0, microsecond=0)
     diff = today - start
     days_checked = diff.days
     total_entries = 0
     while True:
         try:
             user_entries = next(entries)
             for entry in user_entries:
                 total_entries += 1
         except StopIteration:
             # Verify that every entry from the start point was returned
             expected_total = days_checked * len(self.all_users)
             self.assertEqual(total_entries, expected_total)
             return
def test_due_not_pending():
    today = date.today()
    ObjectPaymentPlanInstalmentFactory(
        due=today+relativedelta(days=-1),
        amount=Decimal('1'),
        object_payment_plan=ObjectPaymentPlanFactory(
            content_object=ContactFactory(),
        ),
    )
    ObjectPaymentPlanInstalmentFactory(
        due=today+relativedelta(days=-2),
        state=CheckoutState.objects.fail,
        amount=Decimal('2'),
        object_payment_plan=ObjectPaymentPlanFactory(
            content_object=ContactFactory(),
        ),
    )
    ObjectPaymentPlanInstalmentFactory(
        due=today+relativedelta(days=-3),
        amount=Decimal('3'),
        object_payment_plan=ObjectPaymentPlanFactory(
            content_object=ContactFactory(),
        ),
    )
    result = [p.amount for p in ObjectPaymentPlanInstalment.objects.due]
    assert [Decimal('1'), Decimal('3')] == result
 def get_date(self, line, date):
     value = None
     if line.delay in ('net_days', 'end_month'):
         value = date + relativedelta(days=line.days)
         if line.delay == 'end_month':
             value += relativedelta(day=31)
     return value
Exemplo n.º 5
0
    def setUp(self):
        super(CheckEntries, self).setUp()
        self.user = factories.User()
        self.user2 = factories.User()
        self.superuser = factories.Superuser()
        self.project = factories.Project(
            type__enable_timetracking=True, status__enable_timetracking=True,
            point_person=self.user)

        self.default_data = {
            'user': self.user,
            'project': self.project,
            'seconds_paused': 0,
            'status': Entry.VERIFIED,
        }
        self.good_start = timezone.now() - relativedelta(days=0, hours=8)
        self.good_end = timezone.now() - relativedelta(days=0)
        self.bad_start = timezone.now() - relativedelta(days=1, hours=8)
        self.bad_end = timezone.now() - relativedelta(days=1)
        # Create users for the test
        self.user.first_name = 'first1'
        self.user.last_name = 'last1'
        self.user.save()
        self.user2.first_name = 'first2'
        self.user2.last_name = 'last2'
        self.user2.save()
        self.all_users = [self.user, self.user2, self.superuser]
        # Create a valid entry for all users on every day since 60 days ago
        self.make_entry_bulk(self.all_users, 60)
Exemplo n.º 6
0
    def get_datetime_at_period_ix(self, ix):
        """
        Get the datetime at a given period.

        :param period: The index of the period.

        :returns: The datetime.
        """

        if self.timestep_period_duration == TimePeriod.millisecond:
            return self.start_datetime + timedelta(milliseconds=ix)
        elif self.timestep_period_duration == TimePeriod.second:
            return self.start_datetime + timedelta(seconds=ix)
        elif self.timestep_period_duration == TimePeriod.minute:
            return self.start_datetime + timedelta(minutes=ix)
        elif self.timestep_period_duration == TimePeriod.hour:
            return self.start_datetime + timedelta(hours=ix)
        elif self.timestep_period_duration == TimePeriod.day:
            return self.start_datetime + relativedelta(days=ix)
        elif self.timestep_period_duration == TimePeriod.week:
            return self.start_datetime + relativedelta(days=ix*7)
        elif self.timestep_period_duration == TimePeriod.month:
            return self.start_datetime + relativedelta(months=ix)
        elif self.timestep_period_duration == TimePeriod.year:
            return self.start_datetime + relativedelta(years=ix)
def test_due_plan_deposit():
    today = date.today()
    ObjectPaymentPlanInstalmentFactory(
        due=today+relativedelta(days=-1),
        amount=Decimal('1'),
        object_payment_plan=ObjectPaymentPlanFactory(
            content_object=ContactFactory(),
        ),
    )
    ObjectPaymentPlanInstalmentFactory(
        deposit=True,
        due=today+relativedelta(days=-2),
        amount=Decimal('2'),
        object_payment_plan=ObjectPaymentPlanFactory(
            content_object=ContactFactory(),
        ),
    )
    ObjectPaymentPlanInstalmentFactory(
        due=today+relativedelta(days=-3),
        amount=Decimal('3'),
        object_payment_plan=ObjectPaymentPlanFactory(
            content_object=ContactFactory(),
        ),
    )
    result = [p.amount for p in ObjectPaymentPlanInstalment.objects.due]
    assert [Decimal('1'), Decimal('3')] == result
Exemplo n.º 8
0
 def create_period(cls, fiscalyears, interval=1):
     '''
     Create periods for the fiscal years with month interval
     '''
     Period = Pool().get('account.period')
     to_create = []
     for fiscalyear in fiscalyears:
         period_start_date = fiscalyear.start_date
         while period_start_date < fiscalyear.end_date:
             period_end_date = period_start_date + \
                 relativedelta(months=interval - 1) + \
                 relativedelta(day=31)
             if period_end_date > fiscalyear.end_date:
                 period_end_date = fiscalyear.end_date
             name = datetime_strftime(period_start_date, '%Y-%m')
             if name != datetime_strftime(period_end_date, '%Y-%m'):
                 name += ' - ' + datetime_strftime(period_end_date, '%Y-%m')
             to_create.append({
                 'name': name,
                 'start_date': period_start_date,
                 'end_date': period_end_date,
                 'fiscalyear': fiscalyear.id,
                 'type': 'standard',
                 })
             period_start_date = period_end_date + relativedelta(days=1)
     if to_create:
         Period.create(to_create)
Exemplo n.º 9
0
    def init(self, cr, uid=1):
        """ This view will be used in dashboard
        The reason writing this code here is, we need to check date range from today to first date of fiscal year.
        """
        pool_obj_fy = self.pool['account.fiscalyear']
        today = time.strftime('%Y-%m-%d')
        fy_id = pool_obj_fy.find(cr, uid, exception=False)
        LIST_RANGES = []
        if fy_id:
            fy_start_date = pool_obj_fy.read(cr, uid, fy_id, ['date_start'])['date_start']
            fy_start_date = datetime.strptime(fy_start_date, '%Y-%m-%d')
            last_month_date = datetime.strptime(today, '%Y-%m-%d') - relativedelta(months=1)

            while (last_month_date > fy_start_date):
                LIST_RANGES.append(today + " to " + last_month_date.strftime('%Y-%m-%d'))
                today = (last_month_date- relativedelta(days=1)).strftime('%Y-%m-%d')
                last_month_date = datetime.strptime(today, '%Y-%m-%d') - relativedelta(months=1)

            LIST_RANGES.append(today +" to " + fy_start_date.strftime('%Y-%m-%d'))
            cr.execute('delete from temp_range')

            for range in LIST_RANGES:
                self.pool['temp.range'].create(cr, uid, {'name':range})

        cr.execute("""
            create or replace view report_aged_receivable as (
                select id,name from temp_range
            )""")
Exemplo n.º 10
0
    def get_interval(self):
        today = self.get_today_date()
        weekday = get_weekday_start()

        start = today + relativedelta(weekday=weekday(-1))
        end = start + relativedelta(days=+6)
        return start, end
Exemplo n.º 11
0
    def periods_in_range(self, months_per, start, end):
        one_day = datetime.timedelta(days=1)
        ends = []
        cur_start = start.replace(day=1)

        # in edge cases (all sids filtered out, start/end are adjacent)
        # a test will not generate any returns data
        if len(self.algorithm_returns) == 0:
            return ends

        # ensure that we have an end at the end of a calendar month, in case
        # the return series ends mid-month...
        the_end = end.replace(day=1) + relativedelta(months=1) - one_day
        while True:
            cur_end = cur_start + relativedelta(months=months_per) - one_day
            if(cur_end > the_end):
                break
            cur_period_metrics = RiskMetricsPeriod(
                start_date=cur_start,
                end_date=cur_end,
                returns=self.algorithm_returns,
                benchmark_returns=self.benchmark_returns
            )

            ends.append(cur_period_metrics)
            cur_start = cur_start + relativedelta(months=1)

        return ends
Exemplo n.º 12
0
    def __get_bar_values(self, cr, uid, obj, domain, read_fields, value_field, groupby_field, date_begin, context=None):
        """ Generic method to generate data for bar chart values using SparklineBarWidget.
            This method performs obj.read_group(cr, uid, domain, read_fields, groupby_field).

            :param obj: the target model (i.e. crm_lead)
            :param domain: the domain applied to the read_group
            :param list read_fields: the list of fields to read in the read_group
            :param str value_field: the field used to compute the value of the bar slice
            :param str groupby_field: the fields used to group

            :return list section_result: a list of dicts: [
                                                {   'value': (int) bar_column_value,
                                                    'tootip': (str) bar_column_tooltip,
                                                }
                                            ]
        """
        date_begin = date_begin.date()
        section_result = [{'value': 0,
                           'tooltip': ustr((date_begin + relativedelta.relativedelta(days=i)).strftime('%d %B %Y')),
                           } for i in range(0, self._period_number)]
        group_obj = obj.read_group(cr, uid, domain, read_fields, groupby_field, context=context)
        field = obj._fields.get(groupby_field.split(':')[0])
        pattern = tools.DEFAULT_SERVER_DATE_FORMAT if field.type == 'date' else tools.DEFAULT_SERVER_DATETIME_FORMAT
        for group in group_obj:
            group_begin_date = datetime.strptime(group['__domain'][0][2], pattern).date()
            timedelta = relativedelta.relativedelta(group_begin_date, date_begin)
            section_result[timedelta.days] = {'value': group.get(value_field, 0), 'tooltip': group.get(groupby_field)}
        return section_result
Exemplo n.º 13
0
def archive_month(year, month):
    calendar_start_month = datetime.date(CALENDAR_START.year,
                                         CALENDAR_START.month, 1)
    first_month_redir = redirect(url_for('archive_month',
                                         year=CALENDAR_START.year,
                                         month=CALENDAR_START.month))
    if year == 0 or month == 0:
        return first_month_redir

    date = datetime.date(year, month, 1)
    if date < calendar_start_month:
        return first_month_redir

    today = datetime.datetime.utcnow().date()
    if date > today:
        return redirect(url_for('archive_month',
                                year=today.year,
                                month=today.month))

    cal = calendar.Calendar()
    days = list(cal.itermonthdays2(date.year, date.month))

    prev = date - relativedelta(months=1)
    next = date + relativedelta(months=1)
    prev_disabled = prev < calendar_start_month
    next_disabled = next > today

    return render_template('pages/archive_month.html', date=date, days=days,
                           prev=prev, prev_disabled=prev_disabled,
                           next=next, next_disabled=next_disabled,
                           today=today)
Exemplo n.º 14
0
def eventsJson(request):
    month_start = datetime.datetime(timezone.now().year, timezone.now().month, 1, 0)
    next_month = month_start+relativedelta(months=+1)
    month_end = next_month+relativedelta(seconds=-1)
    
    data = serializers.serialize("json", Event.objects.all())
    return HttpResponse(data, content_type="text/plain")
    def create_invoices(self, cr, uid, ids, context=None):
        sale_obj = self.pool.get('sale.order')
        wizard = self.browse(cr, uid, ids[0], context)
        sale_ids = context.get('active_ids', [])
        invoice_obj = self.pool.get('account.invoice')
        if wizard.advance_payment_method == 'multiple':
            if len(sale_ids) > 1:
                raise Warning(_('Can not use multiple invoices in multiple sales orders at once!'))

            if sale_obj.browse(cr, uid, sale_ids[0], context=context).invoice_ids:
                raise Warning(_('This sale order has already some invoices created!'))

            inv_ids = []
            for invoice_count in range(wizard.invoice_qty - 1):
                for sale_id, inv_values in self._prepare_advance_invoice_vals(cr, uid, ids, context=context):
                    first_invoice_date = datetime.strptime(wizard.first_invoice_date, DEFAULT_SERVER_DATE_FORMAT)
                    invoice_date = (first_invoice_date + relativedelta.relativedelta(months=invoice_count)).strftime(DEFAULT_SERVER_DATE_FORMAT)
                    invoice_id = self._create_invoices(cr, uid, inv_values, sale_id, context=context)
                    invoice_obj.write(cr, uid, invoice_id, {'date_invoice':invoice_date}, context=context)
                    inv_ids.append(invoice_id)

            # create the final invoices of the active sales orders
            invoice_date = (first_invoice_date + relativedelta.relativedelta(months=wizard.invoice_qty-1)).strftime(DEFAULT_SERVER_DATE_FORMAT)
            invoice_id = sale_obj.manual_invoice(cr, uid, sale_ids, context).get('res_id',False)
            invoice_obj.write(cr, uid, invoice_id, {'date_invoice':invoice_date}, context=context)
            
            if context.get('open_invoices', False):
                return sale_obj.action_view_invoice(cr, uid, sale_ids, context=context)
            return {'type': 'ir.actions.act_window_close'}             
        return super(sale_advance_payment_inv, self).create_invoices(cr, uid, ids, context=context)
Exemplo n.º 16
0
Arquivo: main.py Projeto: hechao/stock
def output(date, file_path, bias, cid, name, stock_id, zone, yr):
    s_end_date = date - relativedelta(days=bias)
    s_start_date = date - relativedelta(years=yr)
    
    fmt = "%b"
    
    s_end_date_month_f = s_end_date.strftime(fmt)
    s_start_date_month_f = s_start_date.strftime(fmt)
    
    #print s_end_date, s_start_date
    
    startdate = '%s+%s+%s' % (s_start_date_month_f, s_start_date.day, s_start_date.year)
    enddate = '%s+%s+%s' % (s_end_date_month_f, s_end_date.day, s_end_date.year)
    print "URL using date end %s, start %s" % (enddate, startdate)
    
    num = '200'
    pg = ['0', '200', '400', '600', '800', '1000']
    url_list = []
    stock_pg_datalist = {}
    
    for i in range(yr+1):
        url_list.append('https://www.google.com/finance/historical?cid=%s&startdate=%s&enddate=%s&num=%s&start=%s' % (cid, startdate, enddate, num, pg[i]))
        
    #print url_list
    
    for i in url_list:
        stock_pg_datalist.update(stock_pg_data(i))
    
    current_value = realtime_data(stock_id)
    
    cal_data = calculate_data(current_value, stock_pg_datalist, date)
    
    write_data(name, cid, cal_data[0], cal_data[1], cal_data[2], current_value, zone, stock_id, cal_data[3])
Exemplo n.º 17
0
 def calc_period_prec(self, cr, uid, fiscal_year, context={}):
     fiscalyear_obj = self.pool['account.fiscalyear']
     date_start = (
         str(datetime.strptime(fiscal_year.date_start, '%Y-%m-%d') -
             relativedelta(years=1))[:10])
     date_stop = (
         str(datetime.strptime(fiscal_year.date_stop, '%Y-%m-%d') -
             relativedelta(years=1))[:10])
     id_fy = fiscalyear_obj.search(
         cr, uid,
         [('date_start', '=', date_start), ('date_stop', '=', date_stop)])
     if not id_fy:
         raise osv.except_osv(
             _('Error!'),
             _('Not find the previous exercise for period %s - %s' % (
               date_start, date_stop)))
     # Anno Successivo
     date_start = (
         str(datetime.strptime(fiscal_year.date_start, '%Y-%m-%d') +
             relativedelta(years=1))[:10])
     date_stop = (
         str(datetime.strptime(fiscal_year.date_stop, '%Y-%m-%d') +
             relativedelta(years=1))[:10])
     id_fy1 = fiscalyear_obj.search(
         cr, uid,
         [('date_start', '=', date_start), ('date_stop', '=', date_stop)])
     if not id_fy1:
         raise osv.except_osv(
             _('Error!'),
             _('Not find the next exercise for period %s - %s' % (
               date_start, date_stop)))
     return id_fy[0], id_fy1[0]
Exemplo n.º 18
0
    def calculate_next_run_time(self):

        if self.last_run_time:
            start_date = self.from_date

            if self.repeat_every_minute < 9000:
                one_week_ago = datetime.datetime.now() - relativedelta(weeks=1)
                start_date = start_date.replace(one_week_ago.year,
                                                one_week_ago.month,
                                                one_week_ago.day)

            extra_days = (self.repeat_every_minute / 1400) + 10

            runs = list(rrule(MINUTELY,
                              cache=True,
                              interval=self.repeat_every_minute,
                              until=datetime.date.today() + relativedelta(days=extra_days,
                                                                          weekday=FR(-1)),

                              dtstart=start_date))

            for run in runs:
                if run > self.last_run_time:
                    return run

        return self.from_date
Exemplo n.º 19
0
    def test_link_stats_page(self):
        with mock.patch('django.utils.timezone.now') as mock_now:
            # register usage thirty-eight days ago
            mock_now.return_value = self.now - relativedelta(days=38)
            self.link.register_usage(self.user)

            # register usage eight days ago
            mock_now.return_value = self.now - relativedelta(days=8)
            self.link.register_usage(self.user)

        # register usage now
        self.link.register_usage(self.user)

        stats_url = reverse('link-stats', kwargs={'pk': self.link.pk})
        response = self.app.get(stats_url)

        self.assertEquals(
            response.html.find(class_='usage-seven-days').text,
            '1'
        )
        self.assertEquals(
            response.html.find(class_='usage-thirty-days').text,
            '2'
        )
        self.assertEquals(
            response.html.find(class_='usage-total').text,
            '3'
        )
Exemplo n.º 20
0
 def __init__(self, stdabbr, stdoffset=None,
              dstabbr=None, dstoffset=None,
              start=None, end=None):
     global relativedelta
     if not relativedelta:
         from dateutil import relativedelta
     self._std_abbr = stdabbr
     self._dst_abbr = dstabbr
     if stdoffset is not None:
         self._std_offset = datetime.timedelta(seconds=stdoffset)
     else:
         self._std_offset = ZERO
     if dstoffset is not None:
         self._dst_offset = datetime.timedelta(seconds=dstoffset)
     elif dstabbr and stdoffset is not None:
         self._dst_offset = self._std_offset+datetime.timedelta(hours=+1)
     else:
         self._dst_offset = ZERO
     if start is None:
         self._start_delta = relativedelta.relativedelta(
                 hours=+2, month=4, day=1, weekday=relativedelta.SU(+1))
     else:
         self._start_delta = start
     if end is None:
         self._end_delta = relativedelta.relativedelta(
                 hours=+1, month=10, day=31, weekday=relativedelta.SU(-1))
     else:
         self._end_delta = end
Exemplo n.º 21
0
    def _interval_schedule_hours(self, intervals, hour, backwards=False):
        """ Schedule hours in intervals. The last matching interval is truncated
        to match the specified hours. This method can be applied backwards meaning
        scheduling hours going in the past. In that case truncating last interval
        is done accordingly. If number of hours to schedule is greater than possible
        scheduling in the given intervals, returned result equals intervals.

        :param list intervals:  a list of time intervals
        :param int/float hours: number of hours to schedule. It will be converted
                                into a timedelta, but should be submitted as an
                                int or float
        :param boolean backwards: schedule starting from last hour

        :return list results: a list of time intervals """
        if backwards:
            intervals.reverse()  # first interval is the last working interval of the day
        results = []
        res = timedelta()
        limit = timedelta(hours=hour)
        for interval in intervals:
            res += interval[1] - interval[0]
            if res > limit and not backwards:
                interval = (interval[0], interval[1] + relativedelta(seconds=(limit - res).total_seconds()))
            elif res > limit:
                interval = (interval[0] + relativedelta(seconds=(res - limit).total_seconds()), interval[1])
            results.append(interval)
            if res > limit:
                break
        if backwards:
            results.reverse()  # return interval with increasing starting times
        return results
Exemplo n.º 22
0
    def get_metric_by_month(self, unique_identifier, metric, from_date, limit=10, **kwargs):
        """
        Returns the ``metric`` for ``unique_identifier`` segmented by month
        starting from``from_date``. It will retrieve metrics data starting from the 1st of the
        month specified in ``from_date``

        :param unique_identifier: Unique string indetifying the object this metric is for
        :param metric: A unique name for the metric you want to track
        :param from_date: A python date object
        :param limit: The total number of months to retrive starting from ``from_date``
        """
        conn = kwargs.get("connection", None)
        first_of_month = datetime.date(year=from_date.year, month=from_date.month, day=1)
        metric_key_date_range = self._get_weekly_date_range(
            first_of_month, relativedelta(months=limit))

        date_generator = (first_of_month + relativedelta(months=i) for i in itertools.count())
        #generate a list of first_of_month's in between the start date and the end date
        series = list(itertools.islice(date_generator, limit))

        metric_keys = [self._get_monthly_metric_name(metric, month_date) for month_date in series]

        metric_func = lambda conn: [conn.hmget(
            self._get_weekly_metric_key(
                unique_identifier, metric_key_date), metric_keys) for metric_key_date in metric_key_date_range]

        if conn is not None:
            results = metric_func(conn)
        else:
            with self._analytics_backend.map() as conn:
                results = metric_func(conn)
            series, results = self._parse_and_process_metrics(series, results)

        return series, results
Exemplo n.º 23
0
    def run(self, **kwargs):
        logger.info("TASK :: alarm_dispatcher")

        # Select Alarm where date_start_notice >= now() - 60 minutes and <= now() + 5 minutes
        start_time = datetime.utcnow().replace(tzinfo=utc) + relativedelta(minutes=-60)
        end_time = datetime.utcnow().replace(tzinfo=utc) + relativedelta(minutes=+5)
        alarm_list = Alarm.objects.filter(date_start_notice__range=(start_time, end_time),
                                          status=ALARM_STATUS.PENDING).order_by('date_start_notice')
        # Browse all the Alarm found
        for obj_alarm in alarm_list:
            # Check if there is an existing Event
            if obj_alarm.event:
                obj_alarm.status = ALARM_STATUS.IN_PROCESS
                obj_alarm.save()

                second_towait = obj_alarm.get_time_diff()
                # If second_towait negative then set to 0 to be run directly
                if second_towait <= 0:
                    perform_alarm.delay(obj_alarm.event, obj_alarm)
                else:
                    # Call the Alarm in the future
                    perform_alarm.apply_async(
                        args=[obj_alarm.event, obj_alarm], countdown=second_towait)
            else:
                logger.error("There is no Event attached to this Alarm: %d" % obj_alarm.id)
                ## Mark the Alarm as ERROR
                obj_alarm.status = ALARM_STATUS.FAILURE
                obj_alarm.save()
Exemplo n.º 24
0
def get_period_date_ranges(filters):
		from dateutil.relativedelta import relativedelta
		from_date, to_date = getdate(filters.from_date), getdate(filters.to_date)

		increment = {
			"Monthly": 1,
			"Quarterly": 3,
			"Half-Yearly": 6,
			"Yearly": 12
		}.get(filters.range,1)

		periodic_daterange = []
		for dummy in range(1, 53, increment):
			if filters.range == "Weekly":
				period_end_date = from_date + relativedelta(days=6)
			else:
				period_end_date = from_date + relativedelta(months=increment, days=-1)

			if period_end_date > to_date:
				period_end_date = to_date
			periodic_daterange.append([from_date, period_end_date])

			from_date = period_end_date + relativedelta(days=1)
			if period_end_date == to_date:
				break

		return periodic_daterange
Exemplo n.º 25
0
 def get_context_data(self, **kwargs):
   context = super().get_context_data(**kwargs)
   date = self.get_date()
   context['current_month'] = date
   context['previous_month'] = first_day(date - relativedelta(months=1))
   context['next_month'] = first_day(date + relativedelta(months=1))
   return context
Exemplo n.º 26
0
    def test_inv006_warehouse_stock_report(self):
        """
            @case: inv006
            @description: Warehouse Stock Report
            
            * DOES NOT WORK
        """
        print "\n"
        
        import datetime
        from dateutil.relativedelta import relativedelta

        #@ToDo: Move these into we2unittest
        today = datetime.date.today().strftime("%Y-%m-%d")
        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        now_1_day = (datetime.datetime.now() + relativedelta( days = +1 )).strftime("%Y-%m-%d %H:%M:%S")
        now_1_week = (datetime.date.today() + relativedelta( weeks = +1 )).strftime("%Y-%m-%d %H:%M:%S")
        
        # Login, if not-already done so
        self.login(account="normal", nexturl="inv/inv_item/report")
        
        # INV006
		# Warehouse Stock Report - Using Filter Options
		# Report by Item
		self.search( "inv_item_search",
					 "text",
					 "cans")]
					 )
Exemplo n.º 27
0
    def test_initial_states_with_future(self):
        """
        Test that after the licence has been created some returns has been created according to the return frequency
        and the licence end date
        """
        # issue licence
        # use a one year licence with a monthly return
        start_date = today = date.today()
        end_date = start_date + timedelta(days=366)
        licence_data = {
            'return_frequency': 1,
            'start_date': str(start_date),
            'end_date': str(end_date)
        }
        licence = self._issue_licence(licence_data)
        self.assertIsNotNone(licence)

        # 12 returns should have been created
        rets = Return.objects.all().order_by('due_date')
        self.assertEqual(rets.count(), 12)
        # the first one should be in a month with status 'current'
        current = rets.first()
        self.assertEqual(current.status, 'current')
        next_month = today + relativedelta(months=1)
        self.assertEqual(current.due_date, next_month)
        # the next ones should have the status 'future'
        futures = rets[1:]
        for i, future in enumerate(futures, start=1):
            self.assertEqual(future.status, 'future')
            expected_due_date = next_month + relativedelta(months=i)
            self.assertEqual(future.due_date, expected_due_date)
Exemplo n.º 28
0
	def onchange_description(self, cr, uid, ids, description, recurrence_id, next_invoice_date, context={}):
		txt = tools.ustr(description or '')
		if not next_invoice_date or not recurrence_id:
			return {
			'value': { 'out_description': txt or '' }
		}
		if 'lang' not in context:
			context = { 'lang': self.pool.get('res.users').browse(cr,uid,uid).context_lang }
		start_date = datetime.strptime( next_invoice_date, '%Y-%m-%d' )
		end_date = start_date
		recurrence = self.pool.get( 'product.recurrence.unit' ).browse( cr, uid, recurrence_id, context=context )
		if recurrence:
			if recurrence.unit == 'day':
				end_date = start_date + relativedelta( days=recurrence.value )
			elif recurrence.unit == 'month':
				end_date = start_date + relativedelta( months=recurrence.value )
			elif recurrence.unit == 'year':
				end_date = start_date + relativedelta( years=recurrence.value )
			if recurrence.value > 0:
				end_date -= relativedelta( days=1 )
			if txt:
				if txt != '': txt += ' - '
			else:
				txt = ''
			txt += start_date.strftime( '%d.%m.%Y' ) + ' ' + _( 'to' ) + ' ' + end_date.strftime( '%d.%m.%Y' )
		
		return {
			'value': { 'out_description': txt or '' }
		}
Exemplo n.º 29
0
    def get_cached(self, contract, period):
        end_period_date = datetime.strptime(period, '%Y%m')

        end_period_date += relativedelta(months=1)
        end_period_date = datetime(year=end_period_date.year,
                                   month=end_period_date.month,
                                   day=1)
        end_period_date -= relativedelta(days=1)
        end_period = int(end_period_date.strftime('%Y%m%d'))

        # Set the start period at the begining of the month
        start_period_date = datetime(year=end_period_date.year,
                                     month=end_period_date.month,
                                     day=1)
        start_period = int(start_period_date.strftime('%Y%m%d'))

        query = {'contractId': contract,
                 'day': {'$gte': start_period,
                          '$lte': end_period}}
        res = self._result_collection.find(query).sort('day', 1)
        cached = [x for x in res]
        for elem in cached:
            for hidden_key in self._hidden_keys:
                if hidden_key in elem:
                    elem.pop(hidden_key)
        return {"_items": cached}
Exemplo n.º 30
0
    def sync_month_metric(self, unique_identifier, metric, start_date, end_date):
        """
        Uses the count for each day in the date range to recalculate the counters for the months for
        the ``metric`` for ``unique_identifier``. Useful for updating the counters for week and month after using set_metric_by_day.

        The redis backend supports lists for both ``unique_identifier`` and ``metric`` allowing for the setting of 
        multiple metrics for multiple unique_identifiers efficiently. Not all backends may support this.

        :param unique_identifier: Unique string indetifying the object this metric is for
        :param metric: A unique name for the metric you want to track
        :param start_date: Date syncing starts
        :param end_date: Date syncing end
        """
        metric = [metric] if isinstance(metric, basestring) else metric
        unique_identifier = [unique_identifier] if not isinstance(unique_identifier, (types.ListType, types.TupleType, types.GeneratorType,)) else unique_identifier
        num_months = self._num_months(start_date, end_date)
        first_of_month = datetime.date(year=start_date.year, month=start_date.month, day=1)
        metric_key_date_range = self._get_weekly_date_range(
            first_of_month, relativedelta(months=num_months))

        month_date_generator = (first_of_month + relativedelta(months=i) for i in itertools.count())
        #generate a list of first_of_month's in between the start date and the end date
        months_to_update = list(itertools.islice(month_date_generator, num_months))
        for uid in unique_identifier:
            for single_metric in metric:
                for month in months_to_update:
                    _, series_results = self.get_metric_by_day(uid, single_metric, from_date=month, limit=monthrange(month.year, month.month)[1])
                    month_counter = sum([value for key, value in series_results.items()])

                    hash_key_monthly = self._get_weekly_metric_key(uid, month)
                    monthly_metric_name = self._get_monthly_metric_name(single_metric, month)
                    with self._analytics_backend.map() as conn:
                        conn.hset(hash_key_monthly, monthly_metric_name, month_counter)
Exemplo n.º 31
0
 def _default_valid_until(self):
     return datetime.today() + relativedelta(days=7)
Exemplo n.º 32
0
def make_difference_heatmap(df_current,
                            df_prior,
                            race,
                            event,
                            start_date,
                            end_date,
                            save_fig=False):

    areas = make_areas()
    if datetime.date.fromisoformat(start_date).year == 2014:
        prior_start_date = (datetime.date.fromisoformat(start_date) +
                            relativedelta(years=1)).isoformat()
        prior_end_date = (datetime.date.fromisoformat(end_date) +
                          relativedelta(years=1)).isoformat()
    else:
        prior_start_date = (datetime.date.fromisoformat(start_date) -
                            relativedelta(years=1)).isoformat()
        prior_end_date = (datetime.date.fromisoformat(end_date) -
                          relativedelta(years=1)).isoformat()
    props_post = make_proportions(df_current, race, start_date, end_date)
    props_pre = make_proportions(df_prior, race, prior_start_date,
                                 prior_end_date)
    differences = props_post.subtract(props_pre)
    heat_diff = areas.merge(differences,
                            left_on='serv',
                            right_index=True,
                            how='outer')
    heat_diff = heat_diff.dissolve(by='serv',
                                   aggfunc='first').fillna(0).drop(0)
    event_y = (datetime.date.fromisoformat(start_date) +
               relativedelta(months=2)).year

    cdict = {
        'green': (
            (0.0, 0.0, 0.0),  # no red at 0
            (0.5, 1.0, 1.0),  # all channels set to 1.0 at 0.5 to create white
            (1.0, 0.8, 0.8)),  # set to 0.8 so its not too bright at 1
        'red': (
            (0.0, 0.8, 0.8),  # set to 0.8 so its not too bright at 0
            (0.5, 1.0, 1.0),  # all channels set to 1.0 at 0.5 to create white
            (1.0, 0.0, 0.0)),  # no green at 1
        'blue': (
            (0.0, 0.0, 0.0),  # no blue at 0
            (0.5, 1.0, 1.0),  # all channels set to 1.0 at 0.5 to create white
            (1.0, 0.0, 0.0))  # no blue at 1
    }

    # Create the colormap using the dictionary
    GnRd = colors.LinearSegmentedColormap('GnRd', cdict)

    fig, ax = plt.subplots(1, figsize=(10, 10))
    ax.axis('off')
    ax.set_title(
        f'Change in Proportion of {race} Drivers Stopped By Service Area\n Event: {event} ({event_y})'
        .format(race, event, event_y),
        fontdict={
            'fontsize': '15',
            'fontweight': '3'
        })
    heat_diff.plot(column='prop',
                   cmap=GnRd,
                   linewidth=0.8,
                   ax=ax,
                   edgecolor='0.8',
                   vmin=-.5,
                   vmax=.5,
                   legend=True)
    if save_fig:
        if not os.path.exists(DATA_OUTPATH):
            os.makedirs(DATA_OUTPATH, exist_ok=True)
        fig.savefig(DATA_OUTPATH + '/{r}_{e}_({e_y})'.format(
            r=race.replace('/', '_'), e=event, e_y=event_y))
    return heat_diff
#Stockprice    
hist = ticker.history(period="max")
hist = hist.tail(1)
stockprice = hist.iloc[0]["Open"]

#Risk free rate
risk_free = yf.Ticker("^IRX")
hist = risk_free.history()
hist = hist.tail(1)
r = hist.iloc[0]["Open"]/100

#Dividend approximation based on historic dividend returns. 
dividend = hist["Dividends"]
delta_years_floor = math.floor(time_to_maturity)
delta_years_ceil = delta_years_floor + 1
prior_year_t = today - relativedelta(years=1)
prior_year_expiration = expiration_datetime - relativedelta(years=delta_years_ceil)
dividend_approx = sum(dividend.loc[prior_year_t:today])*delta_years_floor
dividend_approx = dividend_approx + sum(dividend.loc[prior_year_t:prior_year_expiration])

#___________________________________________________________________________________

#4. Definition of four functions for different option types

def European_Call_Div (S0, K, T, sigma, n):

#Calculation of Initial Parameters
  dt = T/n
  u = np.exp(sigma*np.sqrt(dt))
  d = 1/u
  DivRate = dividend_approx / S0
Exemplo n.º 34
0
    def computeFeesInterestPrincipal_ForLoan(dfForLoan):
        # Over the life of the loan, these are the values to be computed and returned by this function.
        cumPrincipal, cumInterest, cumFees = 0, 0, 0

        # Do some up-front validation that the data takes the form expected.
        loanID = dfForLoan[_g.ID_COL].iloc[0]
        if dfForLoan[_g.ORIGINAL_PRINCIPAL_COL].unique().size != 1:
            raise Exception(
                f"Column={_g.ORIGINAL_PRINCIPAL_COL} expected to have unique value for loanID={loanID}."
            )
        if dfForLoan[_g.ORIGINATION_DATE_COL].unique().size != 1:
            raise Exception(
                f"Column={_g.ORIGINATION_DATE_COL} expected to have unique value for loanID={loanID}."
            )
        if dfForLoan[_g.TERM_COL].unique().size != 1:
            raise Exception(
                f"Column={_g.TERM_COL} expected to have unique value for loanID={loanID}."
            )
        if dfForLoan[_g.APR_COL].unique().size != 1:
            raise Exception(
                f"Column={_g.APR_COL} expected to have unique value for loanID={loanID}."
            )

        # Get necessary data from dataframe columns.  Accessing the data thusly preserves the dtype.
        originationDate = dfForLoan[_g.ORIGINATION_DATE_COL].iloc[0]
        termNumMonths = dfForLoan[_g.TERM_COL].iloc[0]
        apr = dfForLoan[_g.APR_COL].iloc[0]
        originalPrincipal = dfForLoan[_g.ORIGINAL_PRINCIPAL_COL].iloc[0]
        numMonthsRemaining = termNumMonths
        principalLedger = originalPrincipal
        interestLedger = 0
        feesLedger = 0

        # Aggregate any rows with the same payment date.
        paymentTS = dfForLoan.groupby(_g.PAYMENT_DATE_COL).agg(
            {_g.PAYMENT_AMOUNT_COL: 'sum'})
        paymentTS.sort_values(
            _g.PAYMENT_DATE_COL,
            inplace=True)  # Chronological order, past --> present

        priorPaymentDate = originationDate
        paymentDeadlineDate = originationDate + pd.DateOffset(
            months=1) + pd.DateOffset(days=13)
        targetMonthlyPayment = principalLedger * (apr / 12 /
                                                  (1 - (1 + apr / 12)**
                                                   (-numMonthsRemaining)))
        paymentLedger = 0
        for index, row in paymentTS.iterrows():
            # From each row, get the date the payment was made, and the cumulative amount of the payment.
            paymentDate = row.name
            paymentAmount = row[_g.PAYMENT_AMOUNT_COL]

            # Compute the accrued simple interest.  This is done on a daily basis, non-compounding.
            daysSinceLastPayment = (paymentDate - priorPaymentDate).days
            interestAmountPerDay = apr / 360.0 * principalLedger
            interestLedger += interestAmountPerDay * daysSinceLastPayment

            # Need to determine whether to assess fees, and how much to assess.
            if paymentDate > paymentDeadlineDate:
                # If *multiple* pay periods have been missed since lass payment, assess a fee for each missed.
                # Again, EXACT methodology here would need to be determined from reading loan-provider's methodology.
                monthsPastDeadline = relativedelta.relativedelta(
                    paymentDate, paymentDeadlineDate).months + 1
                for missedDeadline in range(monthsPastDeadline):
                    outstandingBalance = principalLedger + interestLedger + feesLedger
                    feesLedger += 0.05 * outstandingBalance if 0.05 * outstandingBalance > 20 else 20

            paymentAmountDist = paymentAmount
            if paymentAmountDist > feesLedger:
                paymentAmountDist -= feesLedger
                cumFees += feesLedger
                feesLedger = 0
                if paymentAmountDist > interestLedger:
                    paymentAmountDist -= interestLedger
                    cumInterest += interestLedger
                    interestLedger = 0
                    if paymentAmountDist > principalLedger:
                        # Register the overpayment as a data anomaly?  For now, print to stdout, if overpayment by $5+
                        if paymentAmountDist - principalLedger >= 5:
                            print(
                                f"!!! Payments for loanID={loanID} went over principal by ${paymentAmountDist-principalLedger:.2f}!!!"
                            )
                        paymentAmountDist -= principalLedger
                        cumPrincipal += principalLedger
                        principalLedger = 0
                        break
                    else:
                        principalLedger -= paymentAmountDist
                        cumPrincipal += paymentAmountDist
                else:
                    interestLedger -= paymentAmountDist
                    cumInterest += paymentAmountDist
            else:
                feesLedger -= paymentAmountDist
                cumFees += paymentAmountDist

            # At this point in the code, we've registered the fees and interest that may have accrued since our last
            # payment, we've registered the payment amount, and we've counted the payment amount against any outstanding
            # (1) fees, (2) interest, (3) principal, in that order.
            #
            # Now, we need to address the payment ledger, and the targeted monthly payment.  If this payment exceeds
            # the last recorded payment deadline date, then this payment now counts against a new deadline, with a
            # new targeted monthly payment.
            #
            if paymentDate > paymentDeadlineDate:
                # Any existing paymentLedger prior to this tardy payment should be wiped clean.
                paymentLedger = 0
                # Need to determine whether *multiple* pay periods have been missed since last payment.
                monthsPastDeadline = relativedelta.relativedelta(
                    paymentDate, paymentDeadlineDate).months
                paymentDeadlineDate += pd.DateOffset(
                    months=monthsPastDeadline + 1)
                numMonthsRemaining -= monthsPastDeadline + 1
                if numMonthsRemaining <= 0:
                    break  # If the loan has reached full term, break.
                targetMonthlyPayment = principalLedger * (apr/12 / (1 - (1 + apr/12)**(-numMonthsRemaining))) \
                                       + (interestLedger + feesLedger) / numMonthsRemaining
            paymentLedger += paymentAmount
            if paymentLedger >= targetMonthlyPayment:
                # Our paymentLedger has grown sufficiently large to meet our target monthly payment.  Thus, we
                # zero out the paymentLedger.
                paymentLedger = 0
                paymentDeadlineDate += pd.DateOffset(months=1)
                numMonthsRemaining -= 1
                if numMonthsRemaining <= 0:
                    break  # If the loan has reached full term, break.
                targetMonthlyPayment = principalLedger * (apr/12 / (1 - (1 + apr/12)**(-numMonthsRemaining))) \
                                       + (interestLedger + feesLedger) / numMonthsRemaining

            # Wind forward the prior payment date to this current payment.
            priorPaymentDate = paymentDate

        #--------End of for-loop-------------------------------------------------------------

        return pd.DataFrame({
            _g.ID_COL: [loanID],
            _g.ORIGINAL_PRINCIPAL_COL: [originalPrincipal],
            _g.ORIGINATION_DATE_COL: [originationDate],
            _g.TERM_COL: [termNumMonths],
            _g.APR_COL: [apr],
            _g.CUM_PRINCIPAL_COL: [cumPrincipal],
            _g.CUM_INTEREST_COL: [cumInterest],
            _g.CUM_FEES_COL: [cumFees]
        })
Exemplo n.º 35
0
def main(args):

    # Max number of posts
    max_posts = int(args['<max_posts>'])
    config_path = args['<config_path>']

    # Load configuration file
    with open(config_path) as config_file:
        config = json.loads(config_file.read())

    # To find go to page's FB page, at the end of URL find username
    # E.g. http://facebook.com/walmart, walmart is the username
    list_companies = [config["fb_fanpage_name"]]

    # Save all comments
    save_comments = False

    # The time of last weeks crawl
    last_crawl = datetime.datetime.now() - relativedelta(years=200)
    last_crawl = last_crawl.isoformat()

    # Configure connection and connect
    db_connection = DBConnection(config["db_user"],
                                 config["db_password"],
                                 config["hostname"],
                                 config["database"])
    db_connection.connect()

    # Simple data pull App Secret and App ID
    APP_SECRET = config["APP_SECRET"]
    APP_ID = config["APP_ID"]
    fc = FacebookScrapper(APP_SECRET, APP_ID)

    # Get posts already in database
    db_posts_dict = {}
    db_posts = db_connection.get_posts()
    get_db_posts(db_posts_dict, db_posts)

    # Get last posts url
    post_url = ""
    if os.path.isfile('last_post_url.txt'):
        with open('last_post_url.txt', 'r') as lastpost_file:
            post_url = lastpost_file.read()

    for company in list_companies:

        # Make graph api url with company username
        page = fc.get_page_info(company)
        # Insert the data we pulled into db, commit and close connection
        page_id = db_connection.insert_info(page)
        db_connection.commit()
        db_connection.close()

        posts = []
        # Extract post data
        if post_url == "":
            post_url = fc.create_post_url(company)
        print(post_url)
        fc.scrape_posts_by_date(post_url, last_crawl,
                                posts, company, db_posts_dict, max_posts)

        # Reconnect
        db_connection.connect()
        # Loop through and insert posts
        for post in posts:
            print("storing post data......... " + post[0])
            post.append(page_id)
            # Insert post and commit
            post_id = db_connection.insert_post(post)
            db_connection.commit()
            if save_comments:
                # Retrieving and saving comments
                comment_url = fc.create_comments_url(post[0])
                comments = []
                fc.get_comments_data(comment_url, comments, post_id)
                # Loop through and insert comments
                for comment in comments:
                    db_connection.insert_comment(comment)
                    db_connection.commit()
    db_connection.close()
Exemplo n.º 36
0
def extract_datetime_pt(text, anchorDate=None, default_time=None):
    def clean_string(s):
        # cleans the input string of unneeded punctuation and capitalization
        # among other things
        symbols = [".", ",", ";", "?", "!", "º", "ª"]
        noise_words = [
            "o", "os", "a", "as", "do", "da", "dos", "das", "de", "ao", "aos"
        ]

        for word in symbols:
            s = s.replace(word, "")
        for word in noise_words:
            s = s.replace(" " + word + " ", " ")
        s = s.lower().replace("á", "a").replace("ç", "c").replace(
            "à",
            "a").replace("ã", "a").replace("é", "e").replace("è", "e").replace(
                "ê",
                "e").replace("ó",
                             "o").replace("ò",
                                          "o").replace("-",
                                                       " ").replace("_", "")
        # handle synonims and equivalents, "tomorrow early = tomorrow morning
        synonims = {
            "manha": ["manhazinha", "cedo", "cedinho"],
            "tarde": ["tardinha", "tarde"],
            "noite": ["noitinha", "anoitecer"],
            "todos": ["ao", "aos"],
            "em": ["do", "da", "dos", "das", "de"]
        }
        for syn in synonims:
            for word in synonims[syn]:
                s = s.replace(" " + word + " ", " " + syn + " ")
        # relevant plurals, cant just extract all s in pt
        wordlist = [
            "manhas", "noites", "tardes", "dias", "semanas", "anos", "minutos",
            "segundos", "nas", "nos", "proximas", "seguintes", "horas"
        ]
        for _, word in enumerate(wordlist):
            s = s.replace(word, word.rstrip('s'))
        s = s.replace("meses", "mes").replace("anteriores", "anterior")
        return s

    def date_found():
        return found or \
            (
                datestr != "" or timeStr != "" or
                yearOffset != 0 or monthOffset != 0 or
                dayOffset is True or hrOffset != 0 or
                hrAbs or minOffset != 0 or
                minAbs or secOffset != 0
            )

    if text == "" or not anchorDate:
        return None

    found = False
    daySpecified = False
    dayOffset = False
    monthOffset = 0
    yearOffset = 0
    dateNow = anchorDate
    today = dateNow.strftime("%w")
    currentYear = dateNow.strftime("%Y")
    fromFlag = False
    datestr = ""
    hasYear = False
    timeQualifier = ""

    words = clean_string(text).split(" ")
    timeQualifiersList = ['manha', 'tarde', 'noite']
    time_indicators = [
        "em", "as", "nas", "pelas", "volta", "depois", "estas", "no", "dia",
        "hora"
    ]
    days = [
        'segunda', 'terca', 'quarta', 'quinta', 'sexta', 'sabado', 'domingo'
    ]
    months = [
        'janeiro', 'febreiro', 'marco', 'abril', 'maio', 'junho', 'julho',
        'agosto', 'setembro', 'outubro', 'novembro', 'dezembro'
    ]
    monthsShort = [
        'jan', 'feb', 'mar', 'abr', 'mai', 'jun', 'jul', 'ag', 'set', 'out',
        'nov', 'dec'
    ]
    nexts = ["proximo", "proxima"]
    suffix_nexts = ["seguinte", "subsequente", "seguir"]
    lasts = ["ultimo", "ultima"]
    suffix_lasts = ["passada", "passado", "anterior", "antes"]
    nxts = ["depois", "seguir", "seguida", "seguinte", "proxima", "proximo"]
    prevs = ["antes", "ante", "previa", "previamente", "anterior"]
    froms = [
        "partir", "em", "para", "na", "no", "daqui", "seguir", "depois", "por",
        "proxima", "proximo", "da", "do", "de"
    ]
    thises = [
        "este", "esta", "deste", "desta", "neste", "nesta", "nesse", "nessa"
    ]
    froms += thises
    lists = nxts + prevs + froms + time_indicators
    for idx, word in enumerate(words):
        if word == "":
            continue
        wordPrevPrev = words[idx - 2] if idx > 1 else ""
        wordPrev = words[idx - 1] if idx > 0 else ""
        wordNext = words[idx + 1] if idx + 1 < len(words) else ""
        wordNextNext = words[idx + 2] if idx + 2 < len(words) else ""
        wordNextNextNext = words[idx + 3] if idx + 3 < len(words) else ""

        start = idx
        used = 0
        # save timequalifier for later
        if word in timeQualifiersList:
            timeQualifier = word

        # parse today, tomorrow, yesterday
        elif word == "hoje" and not fromFlag:
            dayOffset = 0
            used += 1
        elif word == "amanha" and not fromFlag:
            dayOffset = 1
            used += 1
        elif word == "ontem" and not fromFlag:
            dayOffset -= 1
            used += 1
        # "before yesterday" and "before before yesterday"
        elif (word == "anteontem" or
              (word == "ante" and wordNext == "ontem")) and not fromFlag:
            dayOffset -= 2
            used += 1
            if wordNext == "ontem":
                used += 1
        elif word == "ante" and wordNext == "ante" and wordNextNext == \
                "ontem" and not fromFlag:
            dayOffset -= 3
            used += 3
        elif word == "anteanteontem" and not fromFlag:
            dayOffset -= 3
            used += 1
        # day after tomorrow
        elif word == "depois" and wordNext == "amanha" and not fromFlag:
            dayOffset += 2
            used = 2
        # day before yesterday
        elif word == "antes" and wordNext == "ontem" and not fromFlag:
            dayOffset -= 2
            used = 2
        # parse 5 days, 10 weeks, last week, next week, week after
        elif word == "dia":
            if wordNext == "depois" or wordNext == "antes":
                used += 1
                if wordPrev and wordPrev[0].isdigit():
                    dayOffset += int(wordPrev)
                    start -= 1
                    used += 1
            elif (wordPrev and wordPrev[0].isdigit() and wordNext not in months
                  and wordNext not in monthsShort):
                dayOffset += int(wordPrev)
                start -= 1
                used += 2
            elif wordNext and wordNext[0].isdigit() and wordNextNext not in \
                    months and wordNextNext not in monthsShort:
                dayOffset += int(wordNext)
                start -= 1
                used += 2

        elif word == "semana" and not fromFlag:
            if wordPrev[0].isdigit():
                dayOffset += int(wordPrev) * 7
                start -= 1
                used = 2
            for w in nexts:
                if wordPrev == w:
                    dayOffset = 7
                    start -= 1
                    used = 2
            for w in lasts:
                if wordPrev == w:
                    dayOffset = -7
                    start -= 1
                    used = 2
            for w in suffix_nexts:
                if wordNext == w:
                    dayOffset = 7
                    start -= 1
                    used = 2
            for w in suffix_lasts:
                if wordNext == w:
                    dayOffset = -7
                    start -= 1
                    used = 2
        # parse 10 months, next month, last month
        elif word == "mes" and not fromFlag:
            if wordPrev[0].isdigit():
                monthOffset = int(wordPrev)
                start -= 1
                used = 2
            for w in nexts:
                if wordPrev == w:
                    monthOffset = 7
                    start -= 1
                    used = 2
            for w in lasts:
                if wordPrev == w:
                    monthOffset = -7
                    start -= 1
                    used = 2
            for w in suffix_nexts:
                if wordNext == w:
                    monthOffset = 7
                    start -= 1
                    used = 2
            for w in suffix_lasts:
                if wordNext == w:
                    monthOffset = -7
                    start -= 1
                    used = 2
        # parse 5 years, next year, last year
        elif word == "ano" and not fromFlag:
            if wordPrev[0].isdigit():
                yearOffset = int(wordPrev)
                start -= 1
                used = 2
            for w in nexts:
                if wordPrev == w:
                    yearOffset = 7
                    start -= 1
                    used = 2
            for w in lasts:
                if wordPrev == w:
                    yearOffset = -7
                    start -= 1
                    used = 2
            for w in suffix_nexts:
                if wordNext == w:
                    yearOffset = 7
                    start -= 1
                    used = 2
            for w in suffix_lasts:
                if wordNext == w:
                    yearOffset = -7
                    start -= 1
                    used = 2
        # parse Monday, Tuesday, etc., and next Monday,
        # last Tuesday, etc.
        elif word in days and not fromFlag:

            d = days.index(word)
            dayOffset = (d + 1) - int(today)
            used = 1
            if dayOffset < 0:
                dayOffset += 7
            for w in nexts:
                if wordPrev == w:
                    dayOffset += 7
                    used += 1
                    start -= 1
            for w in lasts:
                if wordPrev == w:
                    dayOffset -= 7
                    used += 1
                    start -= 1
            for w in suffix_nexts:
                if wordNext == w:
                    dayOffset += 7
                    used += 1
                    start -= 1
            for w in suffix_lasts:
                if wordNext == w:
                    dayOffset -= 7
                    used += 1
                    start -= 1
            if wordNext == "feira":
                used += 1
        # parse 15 of July, June 20th, Feb 18, 19 of February
        elif word in months or word in monthsShort:
            try:
                m = months.index(word)
            except ValueError:
                m = monthsShort.index(word)
            used += 1
            datestr = months[m]
            if wordPrev and wordPrev[0].isdigit():
                # 13 maio
                datestr += " " + wordPrev
                start -= 1
                used += 1
                if wordNext and wordNext[0].isdigit():
                    datestr += " " + wordNext
                    used += 1
                    hasYear = True
                else:
                    hasYear = False

            elif wordNext and wordNext[0].isdigit():
                # maio 13
                datestr += " " + wordNext
                used += 1
                if wordNextNext and wordNextNext[0].isdigit():
                    datestr += " " + wordNextNext
                    used += 1
                    hasYear = True
                else:
                    hasYear = False

            elif wordPrevPrev and wordPrevPrev[0].isdigit():
                # 13 dia maio
                datestr += " " + wordPrevPrev

                start -= 2
                used += 2
                if wordNext and word[0].isdigit():
                    datestr += " " + wordNext
                    used += 1
                    hasYear = True
                else:
                    hasYear = False

            elif wordNextNext and wordNextNext[0].isdigit():
                # maio dia 13
                datestr += " " + wordNextNext
                used += 2
                if wordNextNextNext and wordNextNextNext[0].isdigit():
                    datestr += " " + wordNextNextNext
                    used += 1
                    hasYear = True
                else:
                    hasYear = False

            if datestr in months:
                datestr = ""

        # parse 5 days from tomorrow, 10 weeks from next thursday,
        # 2 months from July
        validFollowups = days + months + monthsShort
        validFollowups.append("hoje")
        validFollowups.append("amanha")
        validFollowups.append("ontem")
        validFollowups.append("anteontem")
        validFollowups.append("agora")
        validFollowups.append("ja")
        validFollowups.append("ante")

        # TODO debug word "depois" that one is failing for some reason
        if word in froms and wordNext in validFollowups:

            if not (wordNext == "amanha" and wordNext == "ontem") and not (
                    word == "depois" or word == "antes" or word == "em"):
                used = 2
                fromFlag = True
            if wordNext == "amanha" and word != "depois":
                dayOffset += 1
            elif wordNext == "ontem":
                dayOffset -= 1
            elif wordNext == "anteontem":
                dayOffset -= 2
            elif wordNext == "ante" and wordNextNext == "ontem":
                dayOffset -= 2
            elif (wordNext == "ante" and wordNextNext == "ante"
                  and wordNextNextNext == "ontem"):
                dayOffset -= 3
            elif wordNext in days:
                d = days.index(wordNext)
                tmpOffset = (d + 1) - int(today)
                used = 2
                if wordNextNext == "feira":
                    used += 1
                if tmpOffset < 0:
                    tmpOffset += 7
                if wordNextNext:
                    if wordNextNext in nxts:
                        tmpOffset += 7
                        used += 1
                    elif wordNextNext in prevs:
                        tmpOffset -= 7
                        used += 1
                dayOffset += tmpOffset
            elif wordNextNext and wordNextNext in days:
                d = days.index(wordNextNext)
                tmpOffset = (d + 1) - int(today)
                used = 3
                if wordNextNextNext:
                    if wordNextNextNext in nxts:
                        tmpOffset += 7
                        used += 1
                    elif wordNextNextNext in prevs:
                        tmpOffset -= 7
                        used += 1
                dayOffset += tmpOffset
                if wordNextNextNext == "feira":
                    used += 1
        if wordNext in months:
            used -= 1
        if used > 0:

            if start - 1 > 0 and words[start - 1] in lists:
                start -= 1
                used += 1

            for i in range(0, used):
                words[i + start] = ""

            if start - 1 >= 0 and words[start - 1] in lists:
                words[start - 1] = ""
            found = True
            daySpecified = True

    # parse time
    timeStr = ""
    hrOffset = 0
    minOffset = 0
    secOffset = 0
    hrAbs = None
    minAbs = None
    military = False

    for idx, word in enumerate(words):
        if word == "":
            continue

        wordPrevPrev = words[idx - 2] if idx > 1 else ""
        wordPrev = words[idx - 1] if idx > 0 else ""
        wordNext = words[idx + 1] if idx + 1 < len(words) else ""
        wordNextNext = words[idx + 2] if idx + 2 < len(words) else ""
        wordNextNextNext = words[idx + 3] if idx + 3 < len(words) else ""
        # parse noon, midnight, morning, afternoon, evening
        used = 0
        if word == "meio" and wordNext == "dia":
            hrAbs = 12
            used += 2
        elif word == "meia" and wordNext == "noite":
            hrAbs = 0
            used += 2
        elif word == "manha":
            if not hrAbs:
                hrAbs = 8
            used += 1
        elif word == "tarde":
            if not hrAbs:
                hrAbs = 15
            used += 1
        elif word == "meio" and wordNext == "tarde":
            if not hrAbs:
                hrAbs = 17
            used += 2
        elif word == "meio" and wordNext == "manha":
            if not hrAbs:
                hrAbs = 10
            used += 2
        elif word == "fim" and wordNext == "tarde":
            if not hrAbs:
                hrAbs = 19
            used += 2
        elif word == "fim" and wordNext == "manha":
            if not hrAbs:
                hrAbs = 11
            used += 2
        elif word == "tantas" and wordNext == "manha":
            if not hrAbs:
                hrAbs = 4
            used += 2
        elif word == "noite":
            if not hrAbs:
                hrAbs = 22
            used += 1
        # parse half an hour, quarter hour
        elif word == "hora" and \
                (wordPrev in time_indicators or wordPrevPrev in
                 time_indicators):
            if wordPrev == "meia":
                minOffset = 30
            elif wordPrev == "quarto":
                minOffset = 15
            elif wordPrevPrev == "quarto":
                minOffset = 15
                if idx > 2 and words[idx - 3] in time_indicators:
                    words[idx - 3] = ""
                words[idx - 2] = ""
            else:
                hrOffset = 1
            if wordPrevPrev in time_indicators:
                words[idx - 2] = ""
            words[idx - 1] = ""
            used += 1
            hrAbs = -1
            minAbs = -1
        # parse 5:00 am, 12:00 p.m., etc
        elif word[0].isdigit():
            isTime = True
            strHH = ""
            strMM = ""
            remainder = ""
            if ':' in word:
                # parse colons
                # "3:00 in the morning"
                stage = 0
                length = len(word)
                for i in range(length):
                    if stage == 0:
                        if word[i].isdigit():
                            strHH += word[i]
                        elif word[i] == ":":
                            stage = 1
                        else:
                            stage = 2
                            i -= 1
                    elif stage == 1:
                        if word[i].isdigit():
                            strMM += word[i]
                        else:
                            stage = 2
                            i -= 1
                    elif stage == 2:
                        remainder = word[i:].replace(".", "")
                        break
                if remainder == "":
                    nextWord = wordNext.replace(".", "")
                    if nextWord == "am" or nextWord == "pm":
                        remainder = nextWord
                        used += 1
                    elif wordNext == "manha":
                        remainder = "am"
                        used += 1
                    elif wordNext == "tarde":
                        remainder = "pm"
                        used += 1
                    elif wordNext == "noite":
                        if 0 < int(word[0]) < 6:
                            remainder = "am"
                        else:
                            remainder = "pm"
                        used += 1
                    elif wordNext in thises and wordNextNext == "manha":
                        remainder = "am"
                        used = 2
                    elif wordNext in thises and wordNextNext == "tarde":
                        remainder = "pm"
                        used = 2
                    elif wordNext in thises and wordNextNext == "noite":
                        remainder = "pm"
                        used = 2
                    else:
                        if timeQualifier != "":
                            military = True
                            if strHH <= 12 and \
                                    (timeQualifier == "manha" or
                                     timeQualifier == "tarde"):
                                strHH += 12

            else:
                # try to parse # s without colons
                # 5 hours, 10 minutes etc.
                length = len(word)
                strNum = ""
                remainder = ""
                for i in range(length):
                    if word[i].isdigit():
                        strNum += word[i]
                    else:
                        remainder += word[i]

                if remainder == "":
                    remainder = wordNext.replace(".", "").lstrip().rstrip()

                if (remainder == "pm" or wordNext == "pm"
                        or remainder == "p.m." or wordNext == "p.m."):
                    strHH = strNum
                    remainder = "pm"
                    used = 1
                elif (remainder == "am" or wordNext == "am"
                      or remainder == "a.m." or wordNext == "a.m."):
                    strHH = strNum
                    remainder = "am"
                    used = 1
                else:
                    if (wordNext == "pm" or wordNext == "p.m."
                            or wordNext == "tarde"):
                        strHH = strNum
                        remainder = "pm"
                        used = 1
                    elif (wordNext == "am" or wordNext == "a.m."
                          or wordNext == "manha"):
                        strHH = strNum
                        remainder = "am"
                        used = 1
                    elif (int(word) > 100
                          and (wordPrev == "o" or wordPrev == "oh"
                               or wordPrev == "zero")):
                        # 0800 hours (pronounced oh-eight-hundred)
                        strHH = int(word) / 100
                        strMM = int(word) - strHH * 100
                        military = True
                        if wordNext == "hora":
                            used += 1
                    elif (wordNext == "hora" and word[0] != '0'
                          and (int(word) < 100 and int(word) > 2400)):
                        # ignores military time
                        # "in 3 hours"
                        hrOffset = int(word)
                        used = 2
                        isTime = False
                        hrAbs = -1
                        minAbs = -1

                    elif wordNext == "minuto":
                        # "in 10 minutes"
                        minOffset = int(word)
                        used = 2
                        isTime = False
                        hrAbs = -1
                        minAbs = -1
                    elif wordNext == "segundo":
                        # in 5 seconds
                        secOffset = int(word)
                        used = 2
                        isTime = False
                        hrAbs = -1
                        minAbs = -1
                    elif int(word) > 100:
                        strHH = int(word) / 100
                        strMM = int(word) - strHH * 100
                        military = True
                        if wordNext == "hora":
                            used += 1

                    elif wordNext == "" or (wordNext == "em"
                                            and wordNextNext == "ponto"):
                        strHH = word
                        strMM = 00
                        if wordNext == "em" and wordNextNext == "ponto":
                            used += 2
                            if wordNextNextNext == "tarde":
                                remainder = "pm"
                                used += 1
                            elif wordNextNextNext == "manha":
                                remainder = "am"
                                used += 1
                            elif wordNextNextNext == "noite":
                                if 0 > int(strHH) > 6:
                                    remainder = "am"
                                else:
                                    remainder = "pm"
                                used += 1

                    elif wordNext[0].isdigit():
                        strHH = word
                        strMM = wordNext
                        military = True
                        used += 1
                        if wordNextNext == "hora":
                            used += 1
                    else:
                        isTime = False

            strHH = int(strHH) if strHH else 0
            strMM = int(strMM) if strMM else 0
            strHH = strHH + 12 if (remainder == "pm"
                                   and 0 < strHH < 12) else strHH
            strHH = strHH - 12 if (remainder == "am"
                                   and 0 < strHH >= 12) else strHH
            if strHH > 24 or strMM > 59:
                isTime = False
                used = 0
            if isTime:
                hrAbs = strHH * 1
                minAbs = strMM * 1
                used += 1

        if used > 0:
            # removed parsed words from the sentence
            for i in range(used):
                words[idx + i] = ""

            if wordPrev == "em" or wordPrev == "ponto":
                words[words.index(wordPrev)] = ""

            if idx > 0 and wordPrev in time_indicators:
                words[idx - 1] = ""
            if idx > 1 and wordPrevPrev in time_indicators:
                words[idx - 2] = ""

            idx += used - 1
            found = True

    # check that we found a date
    if not date_found:
        return None

    if dayOffset is False:
        dayOffset = 0

    # perform date manipulation

    extractedDate = dateNow
    extractedDate = extractedDate.replace(microsecond=0,
                                          second=0,
                                          minute=0,
                                          hour=0)
    if datestr != "":
        en_months = [
            'january', 'february', 'march', 'april', 'may', 'june', 'july',
            'august', 'september', 'october', 'november', 'december'
        ]
        en_monthsShort = [
            'jan', 'feb', 'mar', 'apr', 'may', 'june', 'july', 'aug', 'sept',
            'oct', 'nov', 'dec'
        ]
        for idx, en_month in enumerate(en_months):
            datestr = datestr.replace(months[idx], en_month)
        for idx, en_month in enumerate(en_monthsShort):
            datestr = datestr.replace(monthsShort[idx], en_month)

        temp = datetime.strptime(datestr, "%B %d")
        if not hasYear:
            temp = temp.replace(year=extractedDate.year)
            if extractedDate < temp:
                extractedDate = extractedDate.replace(
                    year=int(currentYear),
                    month=int(temp.strftime("%m")),
                    day=int(temp.strftime("%d")))
            else:
                extractedDate = extractedDate.replace(
                    year=int(currentYear) + 1,
                    month=int(temp.strftime("%m")),
                    day=int(temp.strftime("%d")))
        else:
            extractedDate = extractedDate.replace(
                year=int(temp.strftime("%Y")),
                month=int(temp.strftime("%m")),
                day=int(temp.strftime("%d")))

    if timeStr != "":
        temp = datetime(timeStr)
        extractedDate = extractedDate.replace(hour=temp.strftime("%H"),
                                              minute=temp.strftime("%M"),
                                              second=temp.strftime("%S"))

    if yearOffset != 0:
        extractedDate = extractedDate + relativedelta(years=yearOffset)
    if monthOffset != 0:
        extractedDate = extractedDate + relativedelta(months=monthOffset)
    if dayOffset != 0:
        extractedDate = extractedDate + relativedelta(days=dayOffset)
    if (hrAbs or 0) != -1 and (minAbs or 0) != -1:
        if hrAbs is None and minAbs is None and default_time:
            hrAbs = default_time.hour
            minAbs = default_time.minute
        extractedDate = extractedDate + relativedelta(hours=hrAbs or 0,
                                                      minutes=minAbs or 0)
        if (hrAbs or minAbs) and datestr == "":
            if not daySpecified and dateNow > extractedDate:
                extractedDate = extractedDate + relativedelta(days=1)
    if hrOffset != 0:
        extractedDate = extractedDate + relativedelta(hours=hrOffset)
    if minOffset != 0:
        extractedDate = extractedDate + relativedelta(minutes=minOffset)
    if secOffset != 0:
        extractedDate = extractedDate + relativedelta(seconds=secOffset)

    resultStr = " ".join(words)
    resultStr = ' '.join(resultStr.split())
    resultStr = _pt_pruning(resultStr)
    return [extractedDate, resultStr]
Exemplo n.º 37
0
        if len(open_cases) > 0:
            case_numbers = ",".join([case.case_number for case in open_cases])
            self.record.errors += [
                f"All charges are ineligible because there is one or more open case: {case_numbers}. Open cases with valid dispositions are still included in time analysis. Otherwise they are ignored, so time analysis may be inaccurate for other charges."
            ]
        self.record.errors += self._build_disposition_errors(self.record.charges)
        for charge in self.analyzable_charges:
            eligibility_dates: List[Tuple[date, str]] = []
            other_charges = [c for c in self.analyzable_charges if c != charge]
            dismissals, convictions = Expunger._categorize_charges(other_charges)
            most_recent_blocking_dismissal = Expunger._most_recent_different_case_dismissal(charge, dismissals)
            most_recent_blocking_conviction = Expunger._most_recent_convictions(convictions)

            if charge.convicted():
                eligibility_dates.append(
                    (charge.disposition.date + relativedelta(years=3), "Time-ineligible under 137.225(1)(a)")
                )

            if charge.disposition.status == DispositionStatus.NO_COMPLAINT:
                eligibility_dates.append(
                    (charge.disposition.date + relativedelta(years=1), "Time-ineligible under 137.225(1)(b)")
                )

            if most_recent_blocking_conviction:
                eligibility_dates.append(
                    (
                        most_recent_blocking_conviction.disposition.date + relativedelta(years=10),
                        "Time-ineligible under 137.225(7)(b)",
                    )
                )
Exemplo n.º 38
0
 def mip(self):
     keys = list(self.borrowers.keys())
     for i in range(len(self.data)):
         # self.data.to_csv(self.params['DATA'], sep=';', index=False)
         self.data.loc[i, 'mip'] = insurance.mip(self.data.loc[i, 'balance'], self.signature,
                                                       keys[0].birth, self.signature + relativedelta(months=i),
                                                       keys[1].birth if keys[1] else None,
                                                       self.borrowers[keys[0]],
                                                       self.borrowers[keys[1]] if keys[1] else None)
Exemplo n.º 39
0
def avg_annualised_return(input_df, output_log=False):
'''
This function takes price paid data and returns the
average length of a holding period and the annualised change in value between the purchase
and sale, grouped by the year a holding period ends and the property type.
''' 

    from dateutil import relativedelta
    # Creating a separate field for that combined the house number, flat number 
    # and postcode to ensure multiple properties with the same postcode are treated as separate.
        
    data = input_df.copy()
    data['Date'] = pd.to_datetime(data['Date'])
    data['Year'] = data['Date'].dt.year

    data['num_postcode'] = data['PAON'] + data['SAON'].astype(str) + data['Postcode']
    data['num_postcode'] = data['num_postcode'].astype(str)
    data = data.sort_values('Date', ascending=True)
    working_df = pd.DataFrame(columns=['year', 'type', 'hold_period', 'annualised_return']) 

    # For each
    for address in data['num_postcode']:
        current = data.loc[data['num_postcode'] == address]
        appearances = len(current)
        
        # don't add to new dataset if there is no holding period

        if appearances < 2:
            
            continue
        
        # annualized_return=((1 + total_return)**(months))-1
        if appearances > 1:
            
            for period in range(appearances-1):

                if period == appearances-1:
                    break
                    
                new_type = current['Type'].iloc[period]
                
                total_return = (current['Price'].iloc[period+1] - current['Price'].iloc[period]) / current['Price'].iloc[period]
                
                # calculation plus 1 to avoid divide by zero error. For properties sold in the first month (0), it is treated as month = 1
                hold_period = float(relativedelta.relativedelta(current['Date'].iloc[period+1], current['Date'].iloc[period]).months)+1
                
                # year of the sale (next period)
                year = current['Year'].iloc[period+1]
                
                ann_return = (((1 + total_return)**(12/hold_period))-1)*100
                new_row = {'year': year, 'type': new_type, 'hold_period': hold_period, 'annualised_return': ann_return}
                
                working_df = working_df.append(new_row, ignore_index=True)
                
                
                # I used this for checking / debugging
                if output_log == True:
                    print('---New holding period ---\n')
                    print(new_row)
                    print(hold_period)
                    print('Sale Price: ' + str(current['Price'].iloc[period+1]) + ' Buy Price: ' + str(current['Price'].iloc[period]) + '\n\n')

    return working_df.set_index(['year', 'type']).groupby(level=[0,1]).mean()
Exemplo n.º 40
0
def days_from_now(n):
    now = datetime.datetime.now()
    delta = relativedelta(days=n)
    return (now + delta).strftime('%Y-%m-%d')
Exemplo n.º 41
0
    def survey_submit(self, survey_token, answer_token, **post):
        """ Submit a page from the survey.
        This will take into account the validation errors and store the answers to the questions.
        If the time limit is reached, errors will be skipped, answers will be ignored and
        survey state will be forced to 'done'"""
        # Survey Validation
        access_data = self._get_access_data(survey_token,
                                            answer_token,
                                            ensure_token=True)
        if access_data['validity_code'] is not True:
            return {'error': access_data['validity_code']}
        survey_sudo, answer_sudo = access_data['survey_sudo'], access_data[
            'answer_sudo']

        if answer_sudo.state == 'done':
            return {'error': 'unauthorized'}

        questions, page_or_question_id = survey_sudo._get_survey_questions(
            answer=answer_sudo,
            page_id=post.get('page_id'),
            question_id=post.get('question_id'))

        if not answer_sudo.test_entry and not survey_sudo._has_attempts_left(
                answer_sudo.partner_id, answer_sudo.email,
                answer_sudo.invite_token):
            # prevent cheating with users creating multiple 'user_input' before their last attempt
            return {'error': 'unauthorized'}

        if answer_sudo.survey_time_limit_reached or answer_sudo.question_time_limit_reached:
            if answer_sudo.question_time_limit_reached:
                time_limit = survey_sudo.session_question_start_time + relativedelta(
                    seconds=survey_sudo.session_question_id.time_limit)
                time_limit += timedelta(seconds=3)
            else:
                time_limit = answer_sudo.start_datetime + timedelta(
                    minutes=survey_sudo.time_limit)
                time_limit += timedelta(seconds=10)
            if fields.Datetime.now() > time_limit:
                # prevent cheating with users blocking the JS timer and taking all their time to answer
                return {'error': 'unauthorized'}

        errors = {}
        # Prepare answers / comment by question, validate and save answers
        for question in questions:
            inactive_questions = request.env[
                'survey.question'] if answer_sudo.is_session_answer else answer_sudo._get_inactive_conditional_questions(
                )
            if question in inactive_questions:  # if question is inactive, skip validation and save
                continue
            answer, comment = self._extract_comment_from_answers(
                question, post.get(str(question.id)))
            errors.update(question.validate_question(answer, comment))
            if not errors.get(question.id):
                answer_sudo.save_lines(question, answer, comment)

        if errors and not (answer_sudo.survey_time_limit_reached
                           or answer_sudo.question_time_limit_reached):
            return {'error': 'validation', 'fields': errors}

        if not answer_sudo.is_session_answer:
            answer_sudo._clear_inactive_conditional_answers()

        if answer_sudo.survey_time_limit_reached or survey_sudo.questions_layout == 'one_page':
            answer_sudo._mark_done()
        elif 'previous_page_id' in post:
            # Go back to specific page using the breadcrumb. Lines are saved and survey continues
            return self._prepare_question_html(survey_sudo, answer_sudo,
                                               **post)
        else:
            vals = {'last_displayed_page_id': page_or_question_id}
            if not answer_sudo.is_session_answer:
                next_page = survey_sudo._get_next_page_or_question(
                    answer_sudo, page_or_question_id)
                if not next_page:
                    answer_sudo._mark_done()

            answer_sudo.write(vals)

        return self._prepare_question_html(survey_sudo, answer_sudo)
Exemplo n.º 42
0
    def get_phone_records(self):
        """
        获取通话记录
        :param postsms:
        :return:
        """
        for _ in range(0, 7):  # 最近半年, 可以查询7个月记录

            last = datetime.date.today() - relativedelta(months=+_)
            month = last.strftime("%Y%m")

            queryBillDetailNum_url = 'http://sd.189.cn/selfservice/bill/queryBillDetailNum?tag=iframe_rnval'
            headers = {
                "Accept":
                "application/json",
                "Content-Type":
                "application/json",
                "Host":
                "sd.189.cn",
                "Origin":
                "http://sd.189.cn",
                "Referer":
                "http://sd.189.cn/selfservice/IframeBill/iframeSimple?tag=monthlyDetail",
                "User-Agent":
                "Mozilla/5.0 (Windows NT 6.1; WOW64) "
                "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.181 Safari/537.36"
            }
            queryBillDetailNum_data = {
                "accNbr": self.phoneNumber,
                "billingCycle": month,
                "ticketType": "0"
            }
            queryBillDetailNum_res = self.session.post(
                url=queryBillDetailNum_url,
                headers=headers,
                json=queryBillDetailNum_data,
                cookies=self.cookies)

            queryBillDetailNum_j = queryBillDetailNum_res.json()

            if queryBillDetailNum_j.get('resultMsg') == '成功':

                records = int(
                    queryBillDetailNum_j.get('records'))  # 通话记录条数,每页为20条记录

                if records == 0:
                    print('{}无通话记录'.format(month))
                    continue

                else:
                    pages = records // 20 if records % 20 == 0 else records // 20 + 1

                    try:
                        for pageNo in range(pages):

                            queryBillDetail_url = 'http://sd.189.cn/selfservice/bill/queryBillDetail'
                            queryBillDetail_data = {
                                "accNbr": self.phoneNumber,
                                "billingCycle": month,
                                "pageRecords": "20",
                                "pageNo": str(pageNo + 1),
                                "qtype": "0",
                                "totalPage": "1",
                                "queryType": "6"
                            }

                            queryBillDetail_res = self.session.post(
                                url=queryBillDetail_url,
                                headers=headers,
                                json=queryBillDetail_data,
                                cookies=self.cookies)

                            queryBillDetail_j = queryBillDetail_res.json()

                            if queryBillDetail_j.get(
                                    "ruleId") == '1':  # 身份认证未通过的情况,重新认证
                                self.second_selfservice()

                            elif queryBillDetail_j.get(
                                    "resultMsg") == "服务忙,请稍后再试":
                                self.get_phone_records()

                            elif queryBillDetail_j.get("resultMsg") == "成功":

                                callDetailRecord = []
                                # print(queryBillDetail_j)
                                items = jsonpath.jsonpath(
                                    queryBillDetail_j, "$..items")[0]
                                for _ in items:
                                    txxiangDanModel = dict()
                                    txxiangDanModel['startTime'] = _.get(
                                        'startTime')  # 本次通话发生时间
                                    txxiangDanModel['commPlac'] = _.get(
                                        'position')  # 本次通话发生地点
                                    txxiangDanModel['commMode'] = _.get(
                                        'callType')  # 本次通话方式,主叫/被叫
                                    txxiangDanModel['anotherNm'] = _.get(
                                        'calledNbr')  # 本次通话对方号码
                                    txxiangDanModel['commTime'] = _.get(
                                        'duration')  # 本次通话时长(秒)
                                    txxiangDanModel['commType'] = _.get(
                                        'eventType')  # 本次通话类型 ,无通讯费用
                                    txxiangDanModel['commFee'] = _.get(
                                        'charge')  # 本次通话通信费(元)
                                    callDetailRecord.append(txxiangDanModel)
                                print(callDetailRecord)

                    except Exception as e:
                        print(e)
                        return self.second_selfservice()
            else:
                return self.get_phone_records()
Exemplo n.º 43
0
 def test_humanize_delta_handle_high_units(self):
     """humanize_delta should be able to handle very high units."""
     # Very high maximum units, but it only ever iterates over
     # each value the relativedelta might have.
     self.assertEqual(time.humanize_delta(relativedelta(days=2, hours=2), 'hours', 20), '2 days and 2 hours')
Exemplo n.º 44
0
def main():
	# 引数の処理
	argvs = sys.argv
	_type = ""          # ダウンロードするデータのタイプ(日ごと、1時間ごと、10分ごと)
	_force = False      # 既にhtmlファイル(中身はチェックしない)があるかどうかに関わらず新規にダウンロードする場合はTrue
	if len(argvs) >= 2:
		_type = argvs[1]
		if _type not in "daily hourly 10min real-time": # 引数ミスのチェック
			print("please set argv. e.g. daily, hourly, 10min, real-time.")
			exit()
		if "-f" in argvs:
			_force = True
	else:
		print("please set argv. e.g. daily, hourly, 10min, real-time.")
		exit()

	amedas_nodes = get_amedas_nodes()

	# ダウンロードの対象となっている期間とアメダスの一覧をファイルから読み込む
	target = []
	with open("AMEDAS.ini", "r", encoding="utf-8-sig") as fr:
		lines = fr.readlines()
		start_date = dt.strptime(lines[0], "start=%Y,%m,%d\n")
		end_date = dt.strptime(lines[1], "stop=%Y,%m,%d\n")
		for i in range(3, len(lines)):
			line = lines[i]
			line = line.rstrip()
			line = line.lstrip()
			if len(line) == 0:
				continue
			if "#" in line:
				continue
			field = re.split(r"\t|,|\s+", line)
			print(field)
			block_no, name = field
			while True:                   # Excelで編集した際に文字列先頭の0を無くしちゃうことがあるが、面倒なのでコードで対応
				if len(block_no) >= 4:
					break
				block_no = "0" + block_no
			target.append(block_no)
			
	# もし、最新データが必要であれば設定ファイルの内容を無視して、現時点の時刻データに置き換える
	if _type == "real-time":
		start_date = dt.now()
		end_date = start_date

	# 観測データをダウンロードして保存する
	t = start_date
	while t <= end_date:
		for val in target:
			node = amedas_nodes[val]
			isaccess = node.save(_type, t, force=_force)
			if isaccess:
				time.sleep(0.2)
		if _type == "10min" or _type == "hourly" or _type == "real-time":
			t += td(days=1)
		elif _type == "daily":
			t += relativedelta(months=1)


	"""
Exemplo n.º 45
0
 def get_month(off):
     today = date.today()
     d = today - relativedelta(months=off)
     return date(d.year, d.month, 1)
Exemplo n.º 46
0
    def update(self):
        self.data.update()
        waste_data = self.data.data

        try:
            if waste_data:
                if self.type in waste_data:
                    collection_date = datetime.strptime(
                        waste_data[self.type], "%Y-%m-%d"
                    ).date()

                    # Date in date format "%Y-%m-%d"
                    self._year_month_day_date = str(collection_date)

                    if collection_date:
                        # Set the values of the sensor
                        self._last_update = datetime.today().strftime("%d-%m-%Y %H:%M")

                        # Is the collection date today?
                        self._is_collection_date_today = date.today() == collection_date

                        # Days until collection date
                        delta = collection_date - date.today()
                        self._days_until_collection_date = delta.days

                        # Only show the value if the date is lesser than or equal to (today + timespan_in_days)
                        if collection_date <= date.today() + relativedelta(days=int(self.timespan_in_days)):
                            #if the date does not contain a named day or month, return the date as normal
                            if (self.date_format.find('a') == -1 and self.date_format.find('A') == -1
                            and self.date_format.find('b') == -1 and self.date_format.find('B') == -1):
                                self._state = collection_date.strftime(self.date_format)
                            #else convert the named values to the locale names
                            else:
                                edited_date_format = self.date_format.replace('%a', 'EEE')
                                edited_date_format = edited_date_format.replace('%A', 'EEEE')
                                edited_date_format = edited_date_format.replace('%b', 'MMM')
                                edited_date_format = edited_date_format.replace('%B', 'MMMM')

                                #half babel, half date string... something like EEEE 04-MMMM-2020
                                half_babel_half_date = collection_date.strftime(edited_date_format)

                                #replace the digits with qquoted digits 01 --> '01'
                                half_babel_half_date = re.sub(r"(\d+)", r"'\1'", half_babel_half_date)
                                #transform the EEE, EEEE etc... to a real locale date, with babel
                                locale_date = format_date(collection_date, half_babel_half_date, locale=self.locale)

                                self._state = locale_date
                        else:
                            self._hidden = True
                    else:
                        raise ValueError()
                else:
                    raise ValueError()
            else:
                raise ValueError()
        except ValueError:
            self._state = None
            self._hidden = True
            self._days_until_collection_date = None
            self._year_month_day_date = None
            self._is_collection_date_today = False
            self._last_update = datetime.today().strftime("%d-%m-%Y %H:%M")
Exemplo n.º 47
0
def account_detail(request, id):
    template_name = 'retirement_401k/account_detail.html'
    account = get_object_or_404(Account401K, id=id)
    acct = dict()
    acct['id'] = account.id
    acct['company'] = account.company
    acct['start_date'] = account.start_date
    acct['end_date'] = account.end_date
    acct['employee_contribution'] = account.employee_contribution
    acct['employer_contribution'] = account.employer_contribution
    acct['total'] = account.total
    acct['notes'] = account.notes
    acct['as_on_date'] = account.nav_date
    acct['lv_dollar'] = round(account.units*account.nav, 2)
    acct['units'] = account.units
    acct['latest_value'] = account.latest_value
    if account.goal:
        acct['goal'] = get_goal_name_from_id(account.goal)
    acct['user'] = get_user_name_from_id(account.user)
    acct['roi'] = account.roi
    acct['nav'] = account.nav
    chart_data = get_yearly_contribution(id)
    acct['years'] = chart_data['years']
    acct['er_vals'] = chart_data['er']
    acct['em_vals'] = chart_data['em']
    acct['in_vals'] = chart_data['int']
    acct['total_vals'] = chart_data['total']
    acct['nav_history'] = NAVHistory.objects.filter(account=account)
    #{{fund_vals|safe}}, {{voo_vals|safe}}, {{chart_labels|safe}}
    fund_vals = list()
    spy_vals = list()
    chart_labels = list()
    for nav in NAVHistory.objects.filter(account=account).order_by('nav_date'):
        chart_labels.append(nav.nav_date.strftime('%Y-%m-%d'))
        fund_vals.append(float(nav.nav_value))
        val = None
        if nav.comparision_nav_value and nav.comparision_nav_value != 0:
            val = float(nav.comparision_nav_value)
        else:
            response = YahooFinance2('SPY').get_historical_value(nav.nav_date, nav.nav_date+relativedelta(days=5))
        
            val_date = None
            for k,v in response.items():
                if not val:
                    val = v
                    val_date = k
                else:
                    if val_date > k:
                        val_date = k
                        val = v
            if val:
                nav.comparision_nav_value = round(val, 2)
                nav.save()
            else:
                val = 0
        spy_vals.append(val)
    acct['fund_vals'] = fund_vals
    acct['chart_labels'] = chart_labels
    
    acct['spy_vals'] = spy_vals
    acct['curr_module_id'] = 'id_401k_module'
    return render(request, template_name, acct)
Exemplo n.º 48
0
 def test_humanize_delta_handle_unknown_units(self):
     """humanize_delta should be able to handle unknown units, and will not abort."""
     # Does not abort for unknown units, as the unit name is checked
     # against the attribute of the relativedelta instance.
     self.assertEqual(time.humanize_delta(relativedelta(days=2, hours=2), 'elephants', 2), '2 days and 2 hours')
Exemplo n.º 49
0
 def create(self, vals):
     vals['next_run_date'] = date.today() + relativedelta(days=3)
     return super(Digest, self).create(vals)
Exemplo n.º 50
0
def homepage(request):
    date_now = datetime.date.today()
    katastimata = [
        'Σκάλα', 'Μολάοι Κεντρικό', 'Μολάοι Παιδικό', 'MyModa', 'Boom'
    ]
    search_pro = request.POST.get('search_pro', None)

    try:
        picked_date = request.session['date_now']
    except:
        picked_date = None
        request.session['date_now'] = None

    #stats per month
    start_year = datetime.datetime(datetime.datetime.now().year, 1, 1)
    months_list = []
    month = 1
    months = diff_month(start_year, date_now)
    while month <= months + 1:
        months_list.append(
            datetime.datetime(datetime.datetime.now().year, month, 1).month)
        month += 1
    title = 'Try'
    incomes = AddEsoda.objects.all().filter(
        title__month=date_now.month,
        title__year=date_now.year).order_by('-title')
    incomes_initial = AddEsoda.objects.all().filter(
        title__range=[start_year, date_now])
    date_pick = request.POST.get('date_pick')
    if search_pro:
        incomes = AddEsoda.objects.filter(comments__icontains=search_pro)
    try:
        date_range = date_pick.split('-')
        date_range[0] = date_range[0].replace(' ', '')
        date_range[1] = date_range[1].replace(' ', '')

        date_start = datetime.datetime.strptime(date_range[0], '%m/%d/%Y')
        date_end = datetime.datetime.strptime(date_range[1], '%m/%d/%Y')
        incomes = AddEsoda.objects.all()

        start_next_year = date_start
        end_next_year = date_end

        start_last_year = date_start
        end_last_year = date_end

        start_next_year = start_next_year + relativedelta(
            year=start_next_year.year + 1)
        end_next_year = end_next_year + relativedelta(year=end_next_year.year +
                                                      1)

        #start_next_year = datetime.datetime.strptime(start_next_year, '%m/%d/%Y')
        #end_next_year = datetime.datetime.strptime(end_last_year,'%m/%d/%Y')
        incomes_next_year = incomes.filter(
            title__range=[start_next_year, end_next_year]).order_by('-title')

        start_last_year = start_last_year + relativedelta(
            year=start_last_year.year - 1)
        end_last_year = end_last_year + relativedelta(year=end_last_year.year -
                                                      1)

        incomes_last_year = incomes.filter(
            title__range=[start_last_year, end_last_year]).order_by('-title')

        incomes = incomes.filter(
            title__range=[date_start, date_end]).order_by('-title')
        print(date_end, date_start, start_next_year, end_next_year)
    except:
        date_pick = None

    #get next year reports
    try:
        all_retail_next = incomes_next_year.aggregate(Sum('sinolo_fisikon'))
        all_retail_next = all_retail_next['sinolo_fisikon__sum']
        all_retail_avg_next = incomes_next_year.aggregate(
            Avg('sinolo_fisikon'))
        all_retail_avg_next = all_retail_avg_next['sinolo_fisikon__avg']
    except:
        all_retail_next = 0
        all_retail_avg_next = 0
    try:
        all_incomes_next = incomes_next_year.aggregate(Sum('sinolo_olon'))
        all_incomes_next = all_incomes_next['sinolo_olon__sum']
        all_incomes_avg_next = incomes_next_year.aggregate(Avg('sinolo_olon'))
        all_incomes_avg_next = all_incomes_avg_next['sinolo_olon__avg']
    except:
        all_incomes_next = 0
        all_incomes_avg_next = 0

    try:
        pediko_total_next = incomes_next_year.aggregate(Sum('pediko'))
        pediko_total_next = pediko_total_next['pediko__sum']
        pediko_total_avg_next = incomes_next_year.aggregate(Avg('pediko'))
        pediko_total_avg_next = pediko_total_avg_next['pediko__avg']
    except:
        pediko_total_next = 0
        pediko_total_avg_next = 0

    try:
        topiko_next = incomes_next_year.aggregate(Sum('topiko_katastima'))
        topiko_next = topiko_next['topiko_katastima__sum']
        topiko_avg_next = incomes_next_year.aggregate(Avg('topiko_katastima'))
        topiko_avg_next = topiko_avg_next['topiko_katastima__avg']
    except:
        topiko_next = 0
        topiko_avg_next = 0
    try:
        skala_next = incomes_next_year.aggregate(Sum('skala'))
        skala_next = skala_next['skala__sum']
        skala_avg_next = incomes_next_year.aggregate(Avg('skala'))
        skala_avg_next = skala_avg_next['skala__avg']
    except:
        skala_next = 0
        skala_avg_next = 0
    try:
        my_moda_next = incomes_next_year.aggregate(Sum('mymoda'))
        my_moda_next = my_moda_next['mymoda__sum']
        my_moda_avg_next = incomes_next_year.aggregate(Avg('mymoda'))
        my_moda_avg_next = my_moda_avg_next['mymoda__avg']
    except:
        my_moda_next = 0
        my_moda_avg_next = 0
    #get last year reports
    try:
        all_retail_last = incomes_last_year.aggregate(Sum('sinolo_fisikon'))
        all_retail_last = all_retail_last['sinolo_fisikon__sum']
        all_retail_avg_last = incomes_last_year.aggregate(
            Avg('sinolo_fisikon'))
        all_retail_avg_last = all_retail_avg_last['sinolo_fisikon__avg']
    except:
        all_retail_last = 0
        all_retail_avg_last = 0

    try:
        all_incomes_last = incomes_last_year.aggregate(Sum('sinolo_olon'))
        all_incomes_last = all_incomes_last['sinolo_olon__sum']
        all_incomes_avg_last = incomes_last_year.aggregate(Avg('sinolo_olon'))
        all_incomes_avg_last = all_incomes_avg_last['sinolo_olon__avg']
    except:
        all_incomes_last = 0
        all_incomes_avg_last = 0

    try:
        pediko_total_last = incomes_last_year.aggregate(Sum('pediko'))
        pediko_total_last = pediko_total_last['pediko__sum']
        pediko_total_avg_last = incomes_last_year.aggregate(Avg('pediko'))
        pediko_total_avg_last = pediko_total_avg_last['pediko__avg']
    except:
        pediko_total_last = 0
        pediko_total_avg_last = 0

    try:
        topiko_last = incomes_last_year.aggregate(Sum('topiko_katastima'))
        topiko_last = topiko_last['topiko_katastima__sum']
        topiko_avg_last = incomes_last_year.aggregate(Avg('topiko_katastima'))
        topiko_avg_last = topiko_avg_last['topiko_katastima__avg']
    except:
        topiko_last = 0
        topiko_avg_last = 0

    try:
        skala_last = incomes_last_year.aggregate(Sum('skala'))
        skala_last = skala_last['skala__sum']
        skala_avg_last = incomes_last_year.aggregate(Avg('skala'))
        skala_avg_last = skala_avg_last['skala__avg']
    except:
        skala_last = 0
        skala_avg_last = 0

    try:
        my_moda_last = incomes_last_year.aggregate(Sum('mymoda'))
        my_moda_last = my_moda_last['mymoda__sum']
        my_moda_avg_last = incomes_last_year.aggregate(Avg('mymoda'))
        my_moda_avg_last = my_moda_avg_last['mymoda__avg']
    except:
        my_moda_last = 0
        my_moda_avg_last = 0

    #get reports
    try:
        all_retail = incomes.aggregate(Sum('sinolo_fisikon'))
        all_retail = all_retail['sinolo_fisikon__sum']
        all_retail_avg = incomes.aggregate(Avg('sinolo_fisikon'))
        all_retail_avg = all_retail_avg['sinolo_fisikon__avg']
    except:
        all_retail = 0
        all_retail_avg = 0

    try:
        all_incomes = incomes.aggregate(Sum('sinolo_olon'))
        all_incomes = all_incomes['sinolo_olon__sum']
        all_incomes_avg = incomes.aggregate(Avg('sinolo_olon'))
        all_incomes_avg = all_incomes_avg['sinolo_olon__avg']

    except:
        all_incomes = 0
        all_incomes_avg = 0

    try:
        pediko_total = incomes.aggregate(Sum('pediko'))
        pediko_total = pediko_total['pediko__sum']
        pediko_total_avg = incomes.aggregate(Avg('pediko'))
        pediko_total_avg = pediko_total_avg['pediko__avg']
    except:
        pediko_total = 0
        pediko_total_avg = 0

    try:
        topiko = incomes.aggregate(Sum('topiko_katastima'))
        topiko = topiko['topiko_katastima__sum']
        topiko_avg = incomes.aggregate(Avg('topiko_katastima'))
        topiko_avg = topiko_avg['topiko_katastima__avg']
    except:
        topiko = 0
        topiko_avg = 0

    try:
        skala = incomes.aggregate(Sum('skala'))
        skala = skala['skala__sum']
        skala_avg = incomes.aggregate(Avg('skala'))
        skala_avg = skala_avg['skala__avg']
    except:
        skala = 0
        skala_avg = 0

    try:
        my_moda = incomes.aggregate(Sum('mymoda'))
        my_moda = my_moda['mymoda__sum']
        my_moda_avg = incomes.aggregate(Avg('mymoda'))
        my_moda_avg = my_moda_avg['mymoda__avg']
    except:
        my_moda = 0
        my_moda_avg = 0

    try:
        boom = incomes.aggregate(
            Sum('boom'))['boom__sum'] if incomes.aggregate(Sum('boom')) else 0
        boom_avg = incomes.aggregate(
            Avg('boom'))['boom__avg'] if incomes.aggregate(Avg('boom')) else 0
    except:
        boom = 0
        boom_avg = 0
    try:
        boom_last = incomes_last_year.aggregate(
            Sum('boom'))['boom__sum'] if incomes_last_year.aggregate(
                Sum('boom')) != None else 0
        boom_avg_last = incomes_last_year.aggregate(
            Avg('boom'))['boom__avg'] if incomes_last_year.aggregate(
                Avg('boom')) else 0
        boom_next = incomes_next_year.aggregate(
            Sum('boom'))['boom__sum'] if incomes_next_year.aggregate(
                Sum('boom')) else 0
        boom_avg_next = incomes_next_year.aggregate(
            Avg('boom'))['boom__avg'] if incomes_next_year.aggregate(
                Avg('boom')) else 0

    except:
        boom_last = 0
        boom_avg_last = 0
        boom_next = 0
        boom_avg_next = 0

    total_per_month = []
    for num in months_list:
        month = datetime.datetime.now() - relativedelta(months=num - 1)

        boom_sum = incomes_initial.filter(
            title__month=month.month, title__year=month.year).aggregate(
                Sum('boom'))['boom__sum'] if incomes_initial.filter(
                    title__month=month.month,
                    title__year=month.year).aggregate(
                        Sum('boom'))['boom__sum'] else 0
        try:
            sum_paidiko = incomes_initial.filter(
                title__month=month.month,
                title__year=month.year).aggregate(Sum('pediko'))
            sum_paidiko = sum_paidiko['pediko__sum']
        except:
            sum_paidiko = 0
        try:
            sum_kenriko = incomes_initial.filter(
                title__month=month.month,
                title__year=month.year).aggregate(Sum('topiko_katastima'))
            sum_kenriko = sum_kenriko['topiko_katastima__sum']
        except:
            sum_kenriko = 0
        try:
            sum_skala = incomes_initial.filter(
                title__month=month.month,
                title__year=month.year).aggregate(Sum('skala'))
            sum_skala = sum_skala['skala__sum']
        except:
            sum_skala = 0

        try:
            sum_my_moda = incomes_initial.filter(
                title__month=month.month,
                title__year=month.year).aggregate(Sum('mymoda'))
            sum_my_moda = sum_my_moda['mymoda__sum']
        except:
            sum_my_moda = 0
        try:
            sum_fisikon = incomes_initial.filter(
                title__month=month.month,
                title__year=month.year).aggregate(Sum('sinolo_fisikon'))
            sum_fisikon = sum_fisikon['sinolo_fisikon__sum']
        except:
            sum_fisikon = 0
        try:
            sum_total = incomes_initial.filter(
                title__month=month.month,
                title__year=month.year).aggregate(Sum('sinolo_olon'))
            sum_total = sum_total['sinolo_olon__sum']
        except:
            sum_total = 0

        total_per_month.append((month, sum_paidiko, sum_kenriko, sum_skala,
                                sum_fisikon, sum_my_moda, sum_total, boom_sum))

    #the section of total sum per katastima
    katastima_name = request.POST.get('vendor_name') or None
    month_analysis = []

    this_year = date_now
    years = []
    year_initial = datetime.datetime.now().today().year

    ele = 1
    all_months = [
        ('January', '1'),
        ('February', '2'),
        ('March', '3'),
        ('April', '4'),
        ('May', '5'),
        ('June', '6'),
        ('July', '7'),
        ('August', '8'),
        ('September', '9'),
        ('October', '10'),
        ('November', '11'),
        ('December', '12'),
    ]

    try:
        jk = YearMeter.objects.get(id=1).title
    except:
        jk = 5
    if katastima_name:
        while ele < jk + 1:
            years.append(year_initial)
            year_initial -= 1
            ele += 1

        if katastima_name == 'Σκάλα':
            incomes_initial = AddEsoda.objects.all()
            for month in all_months:
                year_analysis = []
                for yeara in years:
                    try:
                        sum_skala = incomes_initial.filter(
                            title__month=month[1],
                            title__year=yeara).aggregate(Sum('skala'))
                        sum_skala = sum_skala['skala__sum']
                    except:
                        sum_skala = 0
                    year_analysis.append(sum_skala)
                month_analysis.append((month[0], year_analysis))
            final_data = []
            for month in month_analysis:
                final_data.append(month[0])
                try:
                    print(month[1][0] - month[1][1])
                except:
                    print(month[1][0])

            print(final_data)

    if katastima_name == 'Μολάοι Κεντρικό':
        incomes_initial = AddEsoda.objects.all()
        for month in all_months:
            year_analysis = []
            for yeara in years:
                try:
                    sum_skala = incomes_initial.filter(
                        title__month=month[1],
                        title__year=yeara).aggregate(Sum('topiko_katastima'))
                    sum_skala = sum_skala['topiko_katastima__sum']
                except:
                    sum_skala = 0
                year_analysis.append(sum_skala)
            month_analysis.append((month[0], year_analysis))

    if katastima_name == 'Μολάοι Παιδικό':
        incomes_initial = AddEsoda.objects.all()
        for month in all_months:
            year_analysis = []
            for yeara in years:
                try:
                    sum_skala = incomes_initial.filter(
                        title__month=month[1],
                        title__year=yeara).aggregate(Sum('pediko'))
                    sum_skala = sum_skala['pediko__sum']
                except:
                    sum_skala = 0
                year_analysis.append(sum_skala)
            month_analysis.append((month[0], year_analysis))
    if katastima_name == 'MyModa':
        incomes_initial = AddEsoda.objects.all()
        for month in all_months:
            year_analysis = []
            for yeara in years:
                try:
                    sum_skala = incomes_initial.filter(
                        title__month=month[1],
                        title__year=yeara).aggregate(Sum('mymoda'))
                    sum_skala = sum_skala['mymoda__sum']
                except:
                    sum_skala = 0
                year_analysis.append(sum_skala)
            month_analysis.append((month[0], year_analysis))
    if katastima_name == 'Boom':
        incomes_initial = AddEsoda.objects.all()
        for month in all_months:
            year_analysis = []
            for yeara in years:
                sum_boom = incomes_initial.filter(
                    title__month=month[1], title__year=yeara).aggregate(
                        Sum('boom'))['boom__sum'] if incomes_initial.filter(
                            title__month=month[1],
                            title__year=yeara).aggregate(
                                Sum('boom'))['boom__sum'] else 0
                year_analysis.append(sum_boom)
            month_analysis.append((month[0], year_analysis))

    if pediko_total == None:
        pediko_total = 0
    pediko_total_last = pediko_total_last if pediko_total_last else 0
    topiko_last = topiko_last if topiko_last else 0
    skala_last = skala_last if skala_last else 0
    my_moda_last = my_moda_last if my_moda_last else 0
    all_retail_last = all_retail_last if all_retail_last else 0
    all_incomes_last = all_incomes_last if all_incomes_last else 0
    boom_last = boom_last if boom_last else 0
    if topiko == None:
        topiko = 0
    if skala == None:
        skala = 0
    if my_moda == None:
        my_moda = 0
    if all_retail == None:
        all_retail = 0
    if all_incomes == None:
        all_incomes = 0
    if boom == None:
        boom = 0

    diff_bewetween_years = [
        pediko_total - pediko_total_last,
        topiko - topiko_last,
        skala - skala_last,
        my_moda - my_moda_last,
        all_retail - all_retail_last,
        all_incomes - all_incomes_last,
        boom - boom_last,
    ]
    context = {
        'title': title,
        'kat_name': katastima_name,
        'total_per_month': total_per_month,
        'all_esoda': incomes,
        'vendors': katastimata,

        #next year_analysis
        'all_retail_next': all_retail_next,
        'all_retail_avg_next': all_retail_avg_next,
        'all_incomes_next': all_incomes_next,
        'all_incomes_avg_next': all_incomes_avg_next,
        'pediko_total_next': pediko_total_next,
        'pediko_avg_next': pediko_total_avg_next,
        'topiko_next': topiko_next,
        'topiko_avg_next': topiko_avg_next,
        'skala_next': skala_next,
        'skala_avg_next': skala_avg_next,
        'my_moda_next': my_moda_next,
        'my_moda_avg_next': my_moda_avg_next,

        #last year_analysis
        'all_retail_last': all_retail_last,
        'all_retail_avg_last': all_retail_avg_last,
        'all_incomes_last': all_incomes_last,
        'all_incomes_avg_last': all_incomes_avg_last,
        'pediko_total_last': pediko_total_last,
        'pediko_avg_last': pediko_total_avg_last,
        'topiko_last': topiko_last,
        'topiko_avg_last': topiko_avg_last,
        'skala_last': skala_last,
        'skala_avg_last': skala_avg_last,
        'my_moda_last': my_moda_last,
        'my_moda_avg_last': my_moda_avg_last,

        #current target
        'all_retail': all_retail,
        'all_retail_avg': all_retail_avg,
        'all_incomes': all_incomes,
        'all_incomes_avg': all_incomes_avg,
        'pediko_total': pediko_total,
        'pediko_avg': pediko_total_avg,
        'topiko': topiko,
        'topiko_avg': topiko_avg,
        'skala': skala,
        'skala_avg': skala_avg,
        'my_moda': my_moda,
        'my_moda_avg': my_moda_avg,
        'date_pick': date_pick,
        'month_ana': month_analysis,
        'years': years,
        'picked_date': picked_date,
        'year_meter': jk,
        'diff_be': diff_bewetween_years,
        'boom': boom,
        'boom_avg': boom_avg,
        'boom_next': boom_next,
        'boom_last': boom_last,
        'boom_avg_next': boom_avg_next,
        'boom_avg_last': boom_avg_last,
    }
    return render(request, 'katastimata_esoda/homepage.html', context)
                    self.delete_delivery_token_in_charon()   # implemented
                    self.send_email()                        # not implemented
                    return 'DELIVERED'
            elif mover_status == 'FAILED':
                self.update_delivery_status('FAILED') # implemented
                self.delete_delivery_token_in_charon()   # implemented
                # todo: to implement this
                self.send_email()                        # not implemented
                return 'FAILED'
            elif mover_status == 'IN_PROGRESS':
                # this is not in Charon yet, talk to Denis
                delivery_started = parser.parse(self.db_entry().get('delivery_started'))
                # alternative way: checking when the folder was created
                # delivery_started = datetime.datetime.fromtimestamp(os.path.getctime(path))
                today = datetime.datetime.now()
                if delivery_started + relativedelta(days=7) >= today:
                    logger.warning('Delivery has been ongoing for more than 7 days. Project will be marked as "FAILED"')
                    self.update_delivery_status('FAILED')
                    self.delete_delivery_token_in_charon()
                    # todo: to implement this
                    self.send_email()
                    return 'FAILED'
                else:
                    # do nothing
                    return 'IN_PROGRESS'



    def deliver_project(self):
        """ Deliver all samples in a project to grus
            :returns: True if all samples were delivered successfully, False if
Exemplo n.º 52
0
from datetime import datetime
from dateutil.relativedelta import relativedelta
from operator import itemgetter
from traceback import format_exception
from sys import exc_info
from openerp.tools.safe_eval import safe_eval as eval
import re
from openerp.addons.decimal_precision import decimal_precision as dp

from openerp import api
from openerp.osv import fields, osv
from openerp.report import render_report
from openerp.tools.translate import _

_intervalTypes = {
    'hours': lambda interval: relativedelta(hours=interval),
    'days': lambda interval: relativedelta(days=interval),
    'months': lambda interval: relativedelta(months=interval),
    'years': lambda interval: relativedelta(years=interval),
}

DT_FMT = '%Y-%m-%d %H:%M:%S'


class marketing_campaign(osv.osv):
    _name = "marketing.campaign"
    _description = "Marketing Campaign"

    def _count_segments(self, cr, uid, ids, field_name, arg, context=None):
        res = {}
        try:
Exemplo n.º 53
0
class ContactFormPurpose(AbstractPurpose):
    name = "retain due to mailing campaign"
    slug = CONTACT_FORM_SLUG
    expiration_timedelta = relativedelta(months=1)
    fields = "__ALL__"
Exemplo n.º 54
0
 def get_start_date(self):
     """ Find the nearest Monday preceding the start date given on input.
     """
     return (parse(self.request.input.start) + relativedelta(weekday=MO(-1))).strftime('%Y-%m-%d')
Exemplo n.º 55
0
def decode_relativedelta(var: Dict[str, Any]) -> relativedelta.relativedelta:
    if 'weekday' in var:
        var['weekday'] = relativedelta.weekday(*var['weekday'])  # type: ignore
    return relativedelta.relativedelta(**var)
Exemplo n.º 56
0
class FirstNLastNamePurpose(AbstractPurpose):
    """Store First & Last name for 10 years."""
    name = "retain due to internet archive"
    slug = FIRST_AND_LAST_NAME_SLUG
    expiration_timedelta = relativedelta(years=10)
    fields = ("first_name", "last_name")
Exemplo n.º 57
0
def get_year_of(date):
    begin = (datetime_to_midnight(date) -
             relativedelta(months=(date.month - 1), days=(date.day - 1)))
    return begin, begin + relativedelta(years=1)
    def render_html(self, data=None):
        report_obj = self.env['report']
        report = report_obj._get_report_from_name(
            'hr_attendance_report.print_attendance')
        docs = []
        employee_attendance = {}
        totals = {}
        for employee in self.env[report.model].browse(data['ids']):
            employee_attendance[employee.id] = []
            docs.append(employee)
            from_date_s = data.get('form', {}).get('from_date', '')
            to_date_s = data.get('form', {}).get('to_date', '')
            from_date = datetime.strptime(from_date_s, '%Y-%m-%d').date()
            to_date = datetime.strptime(to_date_s, '%Y-%m-%d').date()
            while from_date <= to_date:
                from_date_1 = datetime.strftime(from_date, "%Y-%m-%d %H:%M:%S")
                from_date_2 = datetime.strftime(from_date, "%Y-%m-%d 23:59:59")
                attendances = self.env['hr.attendance'].search(
                    [('employee_id', '=', employee.id),
                     ('name', '>=', from_date_1),
                     ('name', '<=', from_date_2)], order='name asc')
                day_attendances = {'ord_hours': 0, 'in_out_str': '',
                                   'day': from_date_1[8:10]}
                used_ids = []
                while len(attendances) - len(used_ids) >= 2:
                    in_attr = attendances.filtered(
                        lambda r: r.id not in used_ids and
                        r.action == 'sign_in')[0]
                    out_attr = attendances.filtered(
                        lambda r: r.id not in used_ids and
                        r.action == 'sign_out')[0]
                    in_time = fields.Datetime.context_timestamp(
                        self, datetime.strptime(in_attr.name,
                                                "%Y-%m-%d %H:%M:%S"))
                    out_time = fields.Datetime.context_timestamp(
                        self, datetime.strptime(out_attr.name,
                                                "%Y-%m-%d %H:%M:%S"))
                    day_attendances['ord_hours'] += out_attr.worked_hours

                    fields.Datetime.context_timestamp(
                        self, datetime.strptime(attendances[0].name,
                                                "%Y-%m-%d %H:%M:%S"))
                    day_attendances['in_out_str'] += \
                        '%02d:%02d-%02d:%02d | ' % (in_time.hour,
                                                    in_time.minute,
                                                    out_time.hour,
                                                    out_time.minute)
                    used_ids.append(in_attr.id)
                    used_ids.append(out_attr.id)
                if day_attendances['in_out_str']:
                    day_attendances['in_out_str'] = \
                        day_attendances['in_out_str'][:-3]
                if day_attendances['ord_hours']:
                    employee_attendance[employee.id].append(day_attendances)
                from_date += relativedelta(days=1)
            totals[employee.id] = {
                'total': sum(x['ord_hours'] for x in
                             employee_attendance[employee.id]),
                'ordinary': sum(x['ord_hours'] for x in
                                employee_attendance[employee.id]),
                'complementary': 0,
                'extra': 0
            }
        docargs = {
            'doc_ids': data['ids'],
            'doc_model': report.model,
            'docs': docs,
            'attendances': employee_attendance,
            'data': data,
            'totals': totals
        }
        return report_obj.render('hr_attendance_report.print_attendance',
                                 docargs)
Exemplo n.º 59
0
def get_quarter_of(date):
    begin = (datetime_to_midnight(date) -
             relativedelta(months=(date.month % 3) - 1, days=(date.day - 1)))
    return begin, begin + relativedelta(months=3)
Exemplo n.º 60
0
def main():
    # Silence upload.py.
    rietveld.upload.verbosity = 0

    parser = optparse.OptionParser(description=sys.modules[__name__].__doc__)
    parser.add_option('-u',
                      '--user',
                      metavar='<email>',
                      default=os.environ.get('USER'),
                      help='Filter on user, default=%default')
    parser.add_option('-b',
                      '--begin',
                      metavar='<date>',
                      help='Filter issues created after the date (mm/dd/yy)')
    parser.add_option('-e',
                      '--end',
                      metavar='<date>',
                      help='Filter issues created before the date (mm/dd/yy)')
    quarter_begin, quarter_end = get_quarter_of(datetime.today() -
                                                relativedelta(months=2))
    parser.add_option(
        '-Q',
        '--last_quarter',
        action='store_true',
        help='Use last quarter\'s dates, i.e. %s to %s' %
        (quarter_begin.strftime('%Y-%m-%d'), quarter_end.strftime('%Y-%m-%d')))
    parser.add_option('-Y',
                      '--this_year',
                      action='store_true',
                      help='Use this year\'s dates')
    parser.add_option('-w',
                      '--week_of',
                      metavar='<date>',
                      help='Show issues for week of the date (mm/dd/yy)')
    parser.add_option(
        '-W',
        '--last_week',
        action='count',
        help='Show last week\'s issues. Use more times for more weeks.')
    parser.add_option(
        '-a',
        '--auth',
        action='store_true',
        help='Ask to authenticate for instances with no auth cookie')
    parser.add_option('-d',
                      '--deltas',
                      action='store_true',
                      help='Fetch deltas for changes.')
    parser.add_option(
        '--no-referenced-issues',
        action='store_true',
        help='Do not fetch issues referenced by owned changes. Useful in '
        'combination with --changes-by-issue when you only want to list '
        'issues that have also been modified in the same time period.')
    parser.add_option(
        '--skip-own-issues-without-changes',
        action='store_true',
        help='Skips listing own issues without changes when showing changes '
        'grouped by referenced issue(s). See --changes-by-issue for more '
        'details.')

    activity_types_group = optparse.OptionGroup(
        parser, 'Activity Types',
        'By default, all activity will be looked up and '
        'printed. If any of these are specified, only '
        'those specified will be searched.')
    activity_types_group.add_option('-c',
                                    '--changes',
                                    action='store_true',
                                    help='Show changes.')
    activity_types_group.add_option('-i',
                                    '--issues',
                                    action='store_true',
                                    help='Show issues.')
    activity_types_group.add_option('-r',
                                    '--reviews',
                                    action='store_true',
                                    help='Show reviews.')
    activity_types_group.add_option(
        '--changes-by-issue',
        action='store_true',
        help='Show changes grouped by referenced issue(s).')
    parser.add_option_group(activity_types_group)

    output_format_group = optparse.OptionGroup(
        parser, 'Output Format',
        'By default, all activity will be printed in the '
        'following format: {url} {title}. This can be '
        'changed for either all activity types or '
        'individually for each activity type. The format '
        'is defined as documented for '
        'string.format(...). The variables available for '
        'all activity types are url, title and author. '
        'Format options for specific activity types will '
        'override the generic format.')
    output_format_group.add_option(
        '-f',
        '--output-format',
        metavar='<format>',
        default=u'{url} {title}',
        help='Specifies the format to use when printing all your activity.')
    output_format_group.add_option(
        '--output-format-changes',
        metavar='<format>',
        default=None,
        help='Specifies the format to use when printing changes. Supports the '
        'additional variable {reviewers}')
    output_format_group.add_option(
        '--output-format-issues',
        metavar='<format>',
        default=None,
        help='Specifies the format to use when printing issues. Supports the '
        'additional variable {owner}.')
    output_format_group.add_option(
        '--output-format-reviews',
        metavar='<format>',
        default=None,
        help='Specifies the format to use when printing reviews.')
    output_format_group.add_option(
        '--output-format-heading',
        metavar='<format>',
        default=u'{heading}:',
        help='Specifies the format to use when printing headings.')
    output_format_group.add_option(
        '--output-format-no-url',
        default='{title}',
        help='Specifies the format to use when printing activity without url.')
    output_format_group.add_option(
        '-m',
        '--markdown',
        action='store_true',
        help='Use markdown-friendly output (overrides --output-format '
        'and --output-format-heading)')
    output_format_group.add_option(
        '-j',
        '--json',
        action='store_true',
        help='Output json data (overrides other format options)')
    parser.add_option_group(output_format_group)
    auth.add_auth_options(parser)

    parser.add_option('-v',
                      '--verbose',
                      action='store_const',
                      dest='verbosity',
                      default=logging.WARN,
                      const=logging.INFO,
                      help='Output extra informational messages.')
    parser.add_option('-q',
                      '--quiet',
                      action='store_const',
                      dest='verbosity',
                      const=logging.ERROR,
                      help='Suppress non-error messages.')
    parser.add_option(
        '-o',
        '--output',
        metavar='<file>',
        help='Where to output the results. By default prints to stdout.')

    # Remove description formatting
    parser.format_description = (lambda _: parser.description)  # pylint: disable=no-member

    options, args = parser.parse_args()
    options.local_user = os.environ.get('USER')
    if args:
        parser.error('Args unsupported')
    if not options.user:
        parser.error('USER is not set, please use -u')
    options.user = username(options.user)

    logging.basicConfig(level=options.verbosity)

    # python-keyring provides easy access to the system keyring.
    try:
        import keyring  # pylint: disable=unused-import,unused-variable,F0401
    except ImportError:
        logging.warning('Consider installing python-keyring')

    if not options.begin:
        if options.last_quarter:
            begin, end = quarter_begin, quarter_end
        elif options.this_year:
            begin, end = get_year_of(datetime.today())
        elif options.week_of:
            begin, end = (get_week_of(
                datetime.strptime(options.week_of, '%m/%d/%y')))
        elif options.last_week:
            begin, end = (
                get_week_of(datetime.today() -
                            timedelta(days=1 + 7 * options.last_week)))
        else:
            begin, end = (get_week_of(datetime.today() - timedelta(days=1)))
    else:
        begin = dateutil.parser.parse(options.begin)
        if options.end:
            end = dateutil.parser.parse(options.end)
        else:
            end = datetime.today()
    options.begin, options.end = begin, end

    if options.markdown:
        options.output_format_heading = '### {heading}\n'
        options.output_format = '  * [{title}]({url})'
        options.output_format_no_url = '  * {title}'
    logging.info('Searching for activity by %s', options.user)
    logging.info('Using range %s to %s', options.begin, options.end)

    my_activity = MyActivity(options)
    my_activity.show_progress('Loading data')

    if not (options.changes or options.reviews or options.issues
            or options.changes_by_issue):
        options.changes = True
        options.issues = True
        options.reviews = True

    # First do any required authentication so none of the user interaction has to
    # wait for actual work.
    if options.changes or options.changes_by_issue:
        my_activity.auth_for_changes()
    if options.reviews:
        my_activity.auth_for_reviews()

    logging.info('Looking up activity.....')

    try:
        if options.changes or options.changes_by_issue:
            my_activity.get_changes()
        if options.reviews:
            my_activity.get_reviews()
        if options.issues or options.changes_by_issue:
            my_activity.get_issues()
        if not options.no_referenced_issues:
            my_activity.get_referenced_issues()
    except auth.AuthenticationError as e:
        logging.error('auth.AuthenticationError: %s', e)

    my_activity.show_progress('\n')

    my_activity.print_access_errors()

    output_file = None
    try:
        if options.output:
            output_file = open(options.output, 'w')
            logging.info('Printing output to "%s"', options.output)
            sys.stdout = output_file
    except (IOError, OSError) as e:
        logging.error('Unable to write output: %s', e)
    else:
        if options.json:
            my_activity.dump_json()
        else:
            if options.changes:
                my_activity.print_changes()
            if options.reviews:
                my_activity.print_reviews()
            if options.issues:
                my_activity.print_issues()
            if options.changes_by_issue:
                my_activity.print_changes_by_issue(
                    options.skip_own_issues_without_changes)
    finally:
        if output_file:
            logging.info('Done printing to file.')
            sys.stdout = sys.__stdout__
            output_file.close()

    return 0