def generate_header():
dob = dt.datetime(1989, 5, 28, tzinfo=pytz.timezone('utc'))
now = dt.datetime.now(tz=pytz.timezone('utc'))
last_year = now.year - 1
last_week_of_last_year = Week.last_week_of_year(last_year).week
age = relativedelta(now, dob).years
my_birthday_happened_this_year = now > dt.datetime(
now.year, 5, 28, tzinfo=pytz.timezone('utc'))
if my_birthday_happened_this_year:
last_birthday = dt.datetime(now.year, 5, 28)
weeks_lived_this_year = Week.thisweek().week - Week.withdate(
last_birthday).week
else:
last_birthday = dt.datetime(last_year, 5, 28)
weeks_lived_this_year = Week.withdate(
now).week + last_week_of_last_year - Week.withdate(
last_birthday).week
seasons = [
([3, 4, 5], 'Spring ❀'),
([6, 7, 8], 'Summer ☀'),
([9, 10, 11], 'Fall ☕︎'),
([1, 2, 12], 'Winter ❄'),
]
season_week_number = 0
for season in seasons:
if now.month in season[0]:
current_season = season[1]
season_week_number = Week.thisweek().week - Week.withdate(
dt.datetime(
now.year, season[0][0], 1,
tzinfo=pytz.timezone('utc'))).week
if now.month in [1, 2]:
season_week_number += last_week_of_last_year - Week.withdate(
dt.datetime(last_year, 12, 1,
tzinfo=pytz.timezone('utc'))).week
assert season_week_number > 0
# seasonal loader
empty = '░'
empty_amount = empty * (13 - (season_week_number - 1)) * 2
filled = '▓'
filled_amount = filled * (season_week_number - 1) * 2
# Subtracting one because I generate these at the beginning of the week
loader = "{0}{1}".format(filled_amount, empty_amount)
weeks_remaining = "/ {} weeks remaining /".format(13 -
season_week_number)
return "# {0} {1} {2}:13 ㄖ {3}:52\n{4} {5}".format(
age, current_season, season_week_number, weeks_lived_this_year,
loader, weeks_remaining)
async def weekly_negotiated(start: date, end: date, *cuts: Cut) -> Iterator[Sales]:
first = Week.withdate(start)
last = Week.withdate(min(date.today(), end))
start = first.monday()
if last.day(lm_pk610.weekday) < lm_pk610.latest:
last -= 1
records = await Repository(lm_pk610).query(start, last.saturday(), *report_sections(*cuts))
return map(parse_record, records)
async def weekly_formula(start: date, end: date, *cuts: Cut) -> Iterator[Sales]:
first = Week.withdate(start) + 1
last = Week.withdate(end) + 1
start = first.monday()
if last.day(lm_pk620.weekday) < lm_pk620.latest:
last -= 1
records = await Repository(lm_pk620).query(start, last.saturday(), *report_sections(*cuts))
return map(parse_record, records)
def __init__(self, **kwargs):
for k, v in kwargs.iteritems():
self.__setattr__(k, v)
if kwargs["archive_date"]:
self.archive_week = Week.withdate(kwargs["archive_date"])
self.lead_time = kwargs["archive_date"] - kwargs["create_date"]
else:
self.archive_date = kwargs["last_move_date"]
self.archive_week = Week.withdate(kwargs["last_move_date"])
self.lead_time = kwargs["last_move_date"] - kwargs["create_date"]
def w_range(start_date, end_date=None):
weeks_list = []
startWeek = Week.withdate(start_date)
if end_date:
endWeek = Week.withdate(end_date)
else:
endWeek = Week.thisweek()
int_week = startWeek
while int_week < endWeek:
int_week = int_week + 1
weeks_list.append(int_week)
return weeks_list
async def get(start: date, end: date) -> DataFrame:
first = Week.withdate(start) - 1
last = Week.withdate(end)
monday = first.monday()
if last.day(lm_pk610.weekday) > lm_pk610.latest:
last -= 1
end = last.saturday()
formula_sales = await weekly_formula(monday, end, Cut.BELLY)
negotiated_sales = await weekly_negotiated(monday, end, Cut.BELLY)
return bacon_index_report(formula_sales, negotiated_sales)[start:end]
def _populate_year(self, year):
index = year - self.dob.year
start_week = Week.withdate(date(year, self.dob.month, self.dob.day))
end_week = Week.withdate(date(year + 1, self.dob.month, self.dob.day))
next_week = start_week
weeks = []
while next_week.monday() < end_week.monday():
week_info = WeekInfo(next_week)
weeks.append(week_info)
self._weeks[next_week] = week_info
next_week += 1
self._years[year] = dict(year=year, index=index, weeks=weeks)
async def archive(tmp_path: Path):
report_date = date(2018, 8, 20)
archive = Archive(tmp_path, Week.withdate(report_date))
archive.save([{
'slug': 'LM_PK602',
'label': 'Cutout and Primal Values',
'report_date': '08/20/2018',
'pork_carcass': '67.18',
'pork_loin': '75.51',
'pork_butt': '89.55',
'pork_picnic': '41.82',
'pork_rib': '113.95',
'pork_ham': '57.52',
'pork_belly': '77.77'
}, {
'slug': 'LM_PK602',
'label': 'Current Volume',
'report_date': '08/20/2018',
'temp_cuts_total_load': '334.74',
'temp_process_total_load': '39.61'
}], report_date)
assert Path(archive).name == '2018W34D01.zip'
return archive
def handle_noargs(self, **options):
translation.activate('fr')
logging.debug('Command in progress')
week_limit = Week.withdate(Week.thisweek().day(settings.VALIDATING_DAY_OF_WEEK) + relativedelta(days=settings.DELAY_BETWEEN_DEFINITON_N_DELIVERY))
# first changed the status of expired deliveries
deliveries_canceled = models.Delivery.objects.filter(date__lt=week_limit, status='w', subscription__enabled=True)
for delivery in deliveries_canceled:
delivery.status = 'e'
delivery.save()
logging.debug('delivery %d expired' % delivery.id)
# secondly, get all the deliveries with a date higher or equal to J+9 and lesser than J+9+7 with a waiting status and a subscription which accepts direct debit.
deliveries = models.Delivery.objects.filter(date__gte=week_limit, date__lt=week_limit+1, status='w', subscription__direct_debit=True, subscription__enabled=True)
for delivery in deliveries:
delivery.status = 'p'
try:
delivery.save()
except ValueError as e:
logging.debug('delivery %d not payed' % delivery.id)
else:
logging.debug('delivery %d payed' % delivery.id)
translation.deactivate()
def handle_noargs(self, **options):
translation.activate('fr')
week_limit = Week.withdate(Week.thisweek().day(settings.VALIDATING_DAY_OF_WEEK) + relativedelta(days=settings.DELAY_BETWEEN_DEFINITON_N_DELIVERY))
deliveries = models.Delivery.objects.filter(date__lte=week_limit, status='P', subscription__enabled=True).order_by('subscription__customer__account__email')
count=0
for delivery in deliveries:
logger_delivery = logging.getLogger('[%d]' % delivery.id)
subscription = delivery.subscription
customer = subscription.customer
logger_delivery.info(delivery.__unicode__())
for content in delivery.content_set.all():
__extent = content.extent
logger_content = logging.getLogger('[%d] [%20s] [%c] [%3s%%]' % (delivery.id, content.product.name[:20], '*' if content.customized else ' ', __extent))
for contentproduct in content.contentproduct_set.all():
logger_content.info('%d x %20s (%4d) %s' % (contentproduct.quantity, contentproduct.product.name[:20], contentproduct.product.id, contentproduct.product.main_price.supplier_product_url))
if options['browse']:
webbrowser.open(contentproduct.product.main_price.supplier_product_url)
count += 1
if count >= options['pages']:
count = 0
try:
input()
except KeyboardInterrupt:
print('Interrupted'); sys.exit()
logger_delivery.info('')
translation.deactivate()
def week(self):
'Returns the start, end-tuple for a week around self.timestamp'
w = Week.withdate(self.timestamp)
start = clean_day(local_timezone.localize(datetime.combine(w.monday(), datetime.min.time())))
end = start + timedelta(days=6, hours=23, minutes=59, seconds=59)
return (start, end)
def validate_period(period, first_date):
'''
make sure only period is between first_date and today
'''
today = datetime.now().strftime('%Y%m%d')
# Day yyyyMMdd
if type_of_period(period) == 'day':
if period >= first_date and period <= today:
return True
# Week yyyy-Www
elif type_of_period(period) == 'week':
this_week = Week.thisweek()
period_week = Week.fromstring(period)
first_date_week = Week.withdate(datetime.strptime(first_date, '%Y%m%d'))
if period_week >= first_date_week and period_week <= this_week:
return True
# Month yyyyMM
elif type_of_period(period) == 'month':
this_month = datetime.now().strftime('%Y%m')
period_month = period[0:6]
first_date_month = first_date[0:6]
if period_month >= first_date_month and period_month <= this_month:
return True
return False
def get(_, week=None):
# Make your own library for ISO week parsing. this one sucks
if not week:
week = Week.withdate(datetime.now())
else:
try:
ws = week.split("-")
if len(ws) == 3:
week = "".join(ws[0:-1])
week = Week.fromstring(week)
except ValueError:
return (
FailResponse(
week="week path variable must be a proper ISO week date"
),
400,
)
try:
token = Token(request.headers.get("X-API-KEY"))
except:
return FailResponse(token="malformed token"), 400
units = []
if token:
try:
monday = datetime.combine(week.monday(), datetime.min.time())
units = lesson_units(token, monday)
units = list(map(serialize_unit, units))
return SuccessResponse(units=units, week=week.isoformat())
except AuthorizationError as e:
return ErrorResponse(str(e)), 403
else:
return ErrorResponse("Unauthorized"), 401
def weeknum(dt, return_type=1):
"""Return a week number for the given datetime.date like Excel's WEEKNUM function"""
if return_type == 21:
from isoweek import Week
return Week.withdate(dt).week
first_dow = _weeknum_first_dow_map[return_type]
return _weeknum(dt, first_dow)
def validate_period(period, first_date):
'''
make sure only period is between first_date and today
'''
today = datetime.now().strftime('%Y%m%d')
# Day yyyyMMdd
if type_of_period(period) == 'day':
if period >= first_date and period <= today:
return True
# Week yyyy-Www
elif type_of_period(period) == 'week':
this_week = Week.thisweek()
period_week = Week.fromstring(period)
first_date_week = Week.withdate(datetime.strptime(
first_date, '%Y%m%d'))
if period_week >= first_date_week and period_week <= this_week:
return True
# Month yyyyMM
elif type_of_period(period) == 'month':
this_month = datetime.now().strftime('%Y%m')
period_month = period[0:6]
first_date_month = first_date[0:6]
if period_month >= first_date_month and period_month <= this_month:
return True
return False
def set_day_off(team_id: int, date: datetime.date, hours_off: int) -> bool:
"""
Set the number of hours off for a given day. If the number of hours off is
set to 0, the entry is erased from the database, if already there.
:param team_id: The ID of the team for which you're setting the day off
:param date: Date to set
:param hours_off: Number of hours off. Can be a number between 0 and 8
:return: True if there were no issues. False if either the team does not
exist, or an invalid number of hours were sent.
"""
session = db.get_session()
team = session.query(Team).filter(Team.id == team_id).one_or_none()
if not team:
return False
if hours_off < 0 or hours_off > 8:
return False
week = Week.withdate(date).toordinal()
day_off = (
session.query(DayOff)
.filter(DayOff.date == date)
.filter(DayOff.team_id == team_id)
.one_or_none()
)
if day_off:
if hours_off == 0:
session.delete(day_off)
else:
day_off.hours_off = hours_off
elif hours_off != 0:
session.add(DayOff(team=team, date=date, hours_off=hours_off, week=week))
session.commit()
return True
def latest(self) -> date:
now = chicago_time()
release_date = Week.withdate(now.date()).day(self.weekday)
release = chicago_time(self.hour).replace(release_date.year,
release_date.month,
release_date.day)
return release.date() if now > release else (
release - relativedelta(weeks=1)).date()
def test_constructors(self):
w = Week(2011,1)
self.assertTrue(w)
self.assertEqual(str(w), "2011W01")
w = Week(2011,0)
self.assertEqual(str(w), "2010W52")
w = Week(2011,-1)
self.assertEqual(str(w), "2010W51")
w = Week(2011,52)
self.assertEqual(str(w), "2011W52")
w = Week(2011,53)
self.assertEqual(str(w), "2012W01")
w = Week(2011,54)
self.assertEqual(str(w), "2012W02")
w = Week(2009,51)
self.assertEqual(str(w), "2009W51")
w = Week(2009,52)
self.assertEqual(str(w), "2009W52")
w = Week(2009,53)
self.assertEqual(str(w), "2010W01")
w = Week(2009,54)
self.assertEqual(str(w), "2010W02")
w = Week.thisweek()
self.assertTrue(w)
w = Week.fromordinal(1)
self.assertEqual(str(w), "0001W01")
w = Week.fromordinal(2)
self.assertEqual(str(w), "0001W02")
w = Week.fromordinal(521723)
self.assertEqual(str(w), "9999W52")
w = Week.fromstring("2011W01")
self.assertEqual(str(w), "2011W01")
w = Week.fromstring("2011-W01")
self.assertEqual(str(w), "2011W01")
from datetime import date
w = Week.withdate(date(2011, 5, 17))
self.assertEqual(str(w), "2011W20")
self.assertEqual(Week.last_week_of_year(2009), Week(2009, 52))
self.assertEqual(Week.last_week_of_year(2010), Week(2010, 52))
self.assertEqual(Week.last_week_of_year(2011), Week(2011, 52))
self.assertEqual(Week.last_week_of_year(9999), Week(9999, 52))
self.assertRaises(ValueError, lambda: Week(0, 0))
self.assertRaises(ValueError, lambda: Week.fromstring("0000W00"))
self.assertRaises(ValueError, lambda: Week.fromstring("foo"))
self.assertRaises(ValueError, lambda: Week.fromordinal(-1))
self.assertRaises(ValueError, lambda: Week.fromordinal(0))
self.assertRaises(ValueError, lambda: Week.fromordinal(521724))
self.assertRaises(ValueError, lambda: Week.last_week_of_year(0))
self.assertRaises(ValueError, lambda: Week.last_week_of_year(10000))
def save(self, commit=True):
subscription = super().save(commit=False)
bw = Week.fromstring(self.cleaned_data['start'])
ew = Week.withdate( bw.day(1) + relativedelta(months=int(self.cleaned_data['duration'])) )
subscription.end = ew
if commit:
subscription.save()
subscription.create_deliveries()
return subscription
def get_deliveries_from_subscription(subscription_data):
receive_only_once = subscription_data.get('receive_only_once')
bw = Week.fromstring(str(subscription_data.get('start')))
ew = Week.withdate( bw.day(1) + relativedelta(months=int(subscription_data.get('duration'))) )
nb = len(range(0, ew+1-bw, int(subscription_data.get('frequency'))))
init_price = subscription_data.get('size').default_price().price
prices = get_deliveries(nb, init_price)
if receive_only_once: prices = np.array([prices[0]])
deliveries = [(i+1, '%s (%s %s)' % ((bw+i*2).day(settings.DELIVERY_DAY_OF_WEEK).strftime('%d-%m-%Y'), _('Week'), (bw+i*2).week), p) for i,p in enumerate(prices)]
return deliveries, prices
def get_yw(str_date, date_format='%Y-%m-%d'):
"""
get week number within a year, from week 0 to week 52
:param str_date:
:param date_format:
:return:
"""
date_str = change_format(str_date, in_format=date_format, out_format='%Y-%m-%d')
date_obj = datetime.strptime(date_str, '%Y-%m-%d')
w = Week.withdate(date(date_obj.year, date_obj.month, date_obj.day))
return str(w[0]) + '-' + str(w[1] if w[1] > 9 else '0' + str(w[1])) # yyyy-ww
def weekly_incidents(inc):
"""
:param team:
:return:
"""
open_week = Week.withdate(dt.datetime.strptime(inc['opened_at'], '%Y-%m-%d %H:%M:%S').date())
if open_week in incs_by_week.keys():
incs_by_week[open_week] += 1
incs_by_week.update({open_week: incs_by_week[open_week]})
else:
incs_by_week[open_week] = 1
async def get(self, client: Client, end: date) -> Archive:
end = min(date.today(), end)
week = Week.withdate(end)
archive = Archive(Path(self), week)
day = archive.day
if day == 6 or day == end.isoweekday():
return archive
records = await client.fetch(week.day(day), end)
archive.save(records, end)
return archive
def export_to_ical(destination, lessons, start=None, end=None, year=None, weeks=None):
"""
Export the given lessons to ical for the given year and week or start and end date.
The destination must be the path to the ical file to writer.
lessons must be in the same format as returned by AdUnisHSR.
Weeks must be an iterable returning the KW number(int) (eg. 44, 45, 46)
"""
if start is not None and end is not None:
weeks = range(Week.withdate(start).week, Week.withdate(end).week+1)
year = start.year
elif not (weeks is not None and year is not None):
raise TimeTableException('You must either provide a week and a year or start and end date')
cal = Calendar()
cal.add('prodid', '-//timetable2ical//mxm.dk//')
cal.add('version', '2.0')
for week in weeks:
reference = datetime.combine(Week(year, week).monday(), time.min)
# TODO: KWs!
for lesson in lessons:
event = Event()
# print(lesson)
start = reference + timedelta(
days=DAYS_OF_THE_WEEK.index(lesson['day']),
hours=lesson['start_time'].hour,
minutes=lesson['start_time'].minute)
end = start + timedelta(minutes=45)
event.add('summary', "%s (%s)" % (lesson['name'], lesson['teacher']))
event.add('dtstart', start)
event.add('dtend', end)
event.add('categories', lesson['abbrev'])
cal.add_component(event)
with open(destination, 'wb') as f:
f.write(cal.to_ical())
def weekly_incidents(inc):
"""
:param team:
:return:
"""
open_week = Week.withdate(
dt.datetime.strptime(inc['opened_at'], '%Y-%m-%d %H:%M:%S').date())
if open_week in incs_by_week.keys():
incs_by_week[open_week] += 1
incs_by_week.update({open_week: incs_by_week[open_week]})
else:
incs_by_week[open_week] = 1
def prepare_data(partner, min_date, date):
"""
With a time series as input:
- remove future bookings
- apply a threshold to avoid outliers
- fill in the missing dates with zero volume
- generate rolling year TEU
:param partner: pd.DataFrame
:param min_date: first date in whole data, as string
:param date: Requested date as a string
:return: pd.DataFrame
"""
if 'wk' in partner.columns:
partner['etd_wkdat'] = [Week(int(str(x)[0:4]), int(str(x)[4:6])).monday() for x in partner.wk]
partner['etd_week'] = [str(Week.withdate(w)[0])+'-'+'{:02d}'.format(Week.withdate(w)[1]) for w in partner.etd_wkdat]
else:
partner.loc[:, 'etd_wkdat'] = pd.to_datetime(partner.etd_wkdat)
#partner.loc[:, 'extract_date'] = [str(pd.to_datetime(x, yearfirst=True).date()) for x in partner.extract_date]
# Remove future bookings
partner = partner[partner.etd_wkdat <= date]
# Replace outlier values
partner.weekly_teu = replace_outliers(partner.weekly_teu)
# Rolling year TEU: Sum of TEU over a moving window of 1 year
partner['rolling_year_teu'] = generate_rolling_year_teu(partner, date)
# Generate lines for missing dates with 0 in numerical variables
partner = missing_dates(partner, min_date, date)
# Remove 2016 data (only useful for calculating rolling year TEU)
partner.index = range(1, len(partner.index) + 1)
partner = partner.loc[partner.etd_wkdat >= datetime.datetime.strptime('1/1/2017', '%d/%m/%Y').date()]
return partner
def get_yw(str_date, date_format=None):
"""
get week number within a year, from week 0 to week 52
:param str_date:
:param date_format:
:return:
"""
fmt = get_date_format(str_date) if date_format is None else date_format
if fmt is None:
return None
else:
date_str = change_format(str_date, in_format=fmt, out_format='%Y-%m-%d')
date_obj = datetime.strptime(date_str, '%Y-%m-%d')
w = Week.withdate(date(date_obj.year, date_obj.month, date_obj.day))
return str(w[0]) + '-' + str(w[1] if w[1] > 9 else '0' + str(w[1])) # yyyy-ww
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
cw = Week.withdate(Week.thisweek().sunday() + relativedelta(days=9))
start = self.fields['start']
start_choices = [str(w + cw.week - 1) for w in Week.weeks_of_year(cw.year)]
start_date_choices = ['%s (%s %s)' % ((w + cw.week - 1).day(settings.DELIVERY_DAY_OF_WEEK).strftime('%d-%m-%Y'), _('Week'), (w + cw.week - 1).week) for w in Week.weeks_of_year(cw.year)]
start.choices = zip(start_choices, start_date_choices)
start.initial = cw
for field in ['size', 'frequency', 'duration', 'start']:
self.fields[field].widget.attrs['class'] = 'slidebar-select'
for field in ['criterias', 'receive_only_once']:
self.fields[field].widget.attrs['class'] = 'checkbox-select'
for field in ['carrier']:
self.fields[field].widget.attrs['class'] = 'radio-select'
def _busiest_week(feed: Feed) -> Dict[datetime.date, FrozenSet[str]]:
service_ids_by_date = _service_ids_by_date(feed)
trip_counts_by_date = _trip_counts_by_date(feed)
weekly_trip_counts: DefaultDict[Week, int] = defaultdict(int)
weekly_dates: DefaultDict[Week, Set[datetime.date]] = defaultdict(set)
for date in service_ids_by_date.keys():
key = Week.withdate(date)
weekly_trip_counts[key] += trip_counts_by_date[date]
weekly_dates[key].add(date)
def max_by(kv: Tuple[Week, int]) -> Tuple[int, int]:
week, count = kv
return count, -week.toordinal()
week, _ = max(weekly_trip_counts.items(), key=max_by)
dates = sorted(weekly_dates[week])
return {date: service_ids_by_date[date] for date in dates}
def __call__(self, wizard, own_data, form_data, tmp_dict):
# print('subscription done')
# print(tmp_dict)
user = get_user(wizard)
customer = user.customer
thematic = get_thematic(form_data['cart'])
customized = own_data.get('customized', False)
duration = int(own_data.get('duration'))
bw = Week.fromstring(own_data.get('start'))
ew = Week.withdate( bw.day(1) + relativedelta(months=duration) )
subscription = models.Subscription.objects.create(customer=customer, size=own_data['size'], carrier=own_data['carrier'], receive_only_once=own_data['receive_only_once'], frequency=int(own_data['frequency']), start=bw, end=ew, comment=form_data['comment'].get('comment', ''))
subscription.criterias = own_data['criterias']
if thematic and not customized:
for e in thematic.thematicextent_set.all():
subscription.extent_set.create(product=e.product, extent=e.extent, customized=False)
subscription.create_deliveries()
tmp_dict['subscription'] = subscription
deliveries = subscription.delivery_set.order_by('date')
mm.Message.objects.create_message(participants=[customer], subject=_('Votre abonnement %(subscription_id)d a été crée') % {'subscription_id': subscription.id}, body=_(
"""Bonjour %(name)s,
Nous sommes heureux de vous annoncer que votre abonnement %(subscription_id)d a été crée, il est accessible à l'adresse suivante :
http://www.vegeclic.fr/carts/subscriptions/%(subscription_id)d/deliveries/
Bien cordialement,
Végéclic.
"""
) % {'name': customer.main_address.__unicode__() if customer.main_address else '', 'date': deliveries[0].get_date_display(), 'subscription_id': subscription.id})
return True
def __call__(self, wizard, form, step, data, files):
subscription_data = wizard.get_cleaned_data_for_step('subscription') or {}
if not subscription_data: return form
user = get_user(wizard)
if user:
form.balance = user.customer.wallet.balance_in_target_currency()
form.balance_inversed = form.balance*-1
form.currency = user.customer.wallet.target_currency
form.receive_only_once = subscription_data.get('receive_only_once')
form.price = subscription_data.get('size').default_price()
form.price_rate = 1+settings.DEGRESSIVE_PRICE_RATE/100
bw = Week.fromstring(str(subscription_data.get('start')))
ew = Week.withdate( bw.day(1) + relativedelta(months=int(subscription_data.get('duration'))) )
deliveries, prices = get_deliveries_from_subscription(subscription_data)
form.fields['nb_deliveries'].choices = [(k+1, '%d %s' % (k+1, _('échéance(s)'))) for k in range(len(prices))]
return form
def first_date_of_week_of_date(_date):
return Week.withdate(_date).monday()
def test_constructors(self):
w = Week(2011, 1)
self.assertTrue(w)
self.assertEqual(str(w), "2011W01")
w = Week(2011, 0)
self.assertEqual(str(w), "2010W52")
w = Week(2011, -1)
self.assertEqual(str(w), "2010W51")
w = Week(2011, 52)
self.assertEqual(str(w), "2011W52")
w = Week(2011, 53)
self.assertEqual(str(w), "2012W01")
w = Week(2011, 54)
self.assertEqual(str(w), "2012W02")
w = Week(2009, 51)
self.assertEqual(str(w), "2009W51")
w = Week(2009, 52)
self.assertEqual(str(w), "2009W52")
w = Week(2009, 53)
self.assertEqual(str(w), "2009W53")
w = Week(2009, 54)
self.assertEqual(str(w), "2010W01")
w = Week.thisweek()
self.assertTrue(w)
w = Week.fromordinal(1)
self.assertEqual(str(w), "0001W01")
w = Week.fromordinal(2)
self.assertEqual(str(w), "0001W02")
w = Week.fromordinal(521723)
self.assertEqual(str(w), "9999W52")
w = Week.fromstring("2011W01")
self.assertEqual(str(w), "2011W01")
w = Week.fromstring("2011-W01")
self.assertEqual(str(w), "2011W01")
from datetime import date
w = Week.withdate(date(2011, 5, 17))
self.assertEqual(str(w), "2011W20")
weeks = list(Week.weeks_of_year(2009))
self.assertEqual(len(weeks), 53)
self.assertEqual(weeks[0], Week(2009, 1))
self.assertEqual(weeks[-1], Week(2009, 53))
weeks = list(Week.weeks_of_year(2011))
self.assertEqual(len(weeks), 52)
self.assertEqual(weeks[0], Week(2011, 1))
self.assertEqual(weeks[-1], Week(2011, 52))
self.assertEqual(Week.last_week_of_year(2009), Week(2009, 53))
self.assertEqual(Week.last_week_of_year(2010), Week(2010, 52))
self.assertEqual(Week.last_week_of_year(2011), Week(2011, 52))
self.assertEqual(Week.last_week_of_year(9999), Week(9999, 52))
self.assertRaises(ValueError, lambda: Week(0, 0))
self.assertRaises(ValueError, lambda: Week.fromstring("0000W00"))
self.assertRaises(ValueError, lambda: Week.fromstring("foo"))
self.assertRaises(ValueError, lambda: Week.fromordinal(-1))
self.assertRaises(ValueError, lambda: Week.fromordinal(0))
self.assertRaises(ValueError, lambda: Week.fromordinal(521724))
self.assertRaises(ValueError, lambda: Week.last_week_of_year(0))
self.assertRaises(ValueError, lambda: Week.last_week_of_year(10000))
"-s", "--settings",
dest="settings",
help="Settings",
metavar="SETTINGS"
)
(options, args) = option_parser.parse_args()
try:
date = date(*map(int, options.week_date.split('-')))
except ValueError:
sys.exit('Invalid date format')
except AttributeError:
date = date.today()
week = Week.withdate(date)
start_date = week.monday()
end_date = (week + 1).monday()
try:
contract_name = options.settings
settings_dict = settings.config[contract_name]
except:
contract_name = settings.default_config
settings_dict = settings.config[contract_name]
if options.filename is None:
filename = 'invoice-%s-%s.pdf' % (contract_name, week.sunday())
else:
filename = options.filename
def week_from_date(dd):
dt = pd.to_datetime(dd)
return Week.withdate(dt)[1] # week number
async def get_recent(n: int) -> DataFrame:
today = date.today()
first = Week.withdate(today) - n - 1
report = await get(first.monday(), today)
return report.tail(n)
#log('UKBot-uploader starting at %s (server time), %s (wiki time)' % (runstart.strftime('%F %T'), runstart.astimezone(wiki_tz).strftime('%F %T')))
host = config['homesite']
homesite = mwclient.Site(host)
now = server_tz.localize(datetime.now())
if args.page is not None:
ktitle = args.page.decode('utf-8')
else:
log(' No page specified. Using default page')
ktitle = config['pages']['default']
# subtract a few hours, so we close last week's contest right after midnight
#ktitle = (now - timedelta(hours=1)).astimezone(wiki_tz).strftime(ktitle.encode('utf-8')).decode('utf-8')
ktitle = config['pages']['default']
w = Week.withdate((now - timedelta(hours=3)).astimezone(wiki_tz).date())
# subtract one hour, so we close last week's contest right after midnight
ktitle = ktitle % { 'year': w.year, 'week': w.week }
# Is ktitle redirect? Resolve
log('@ ktitle is %s' % ktitle)
pp = homesite.api('query', prop='pageprops', titles=ktitle, redirects='1')
if 'redirects' in pp['query']:
ktitle = pp['query']['redirects'][0]['to']
log(' -> Redirected to: %s' % ktitle)
kpage = homesite.pages[ktitle]
if not kpage.exists:
log(' !! kpage does not exist! Exiting')
sys.exit(0)
def calendar_weeks(self, leading_weeks=True):
# session_dates is a list of tuples in this format -
# (date, day_start_at, day_end_at, event_count)
session_dates = list(
db.session.query('date', 'day_start_at', 'day_end_at',
'count').from_statement(
db.text('''
SELECT
DATE_TRUNC('day', "start_at" AT TIME ZONE :timezone) AS date,
MIN(start_at) as day_start_at,
MAX(end_at) as day_end_at,
COUNT(*) AS count
FROM "session" WHERE "project_id" = :project_id AND "start_at" IS NOT NULL AND "end_at" IS NOT NULL
GROUP BY date ORDER BY date;
''')).params(timezone=self.timezone.zone,
project_id=self.id))
session_dates_dict = {
date.date(): {
'day_start_at': day_start_at,
'day_end_at': day_end_at,
'count': count,
}
for date, day_start_at, day_end_at, count in session_dates
}
# FIXME: This doesn't work. This code needs to be tested in isolation
# session_dates = db.session.query(
# db.cast(
# db.func.date_trunc('day', db.func.timezone(self.timezone.zone, Session.start_at)),
# db.Date).label('date'),
# db.func.count().label('count')
# ).filter(
# Session.project == self,
# Session.scheduled
# ).group_by(db.text('date')).order_by(db.text('date'))
# if the project's week is within next 2 weeks, send current week as well
now = utcnow().astimezone(self.timezone)
current_week = Week.withdate(now)
if leading_weeks and self.schedule_start_at is not None:
schedule_start_week = Week.withdate(self.schedule_start_at)
# session_dates is a list of tuples in this format -
# (date, day_start_at, day_end_at, event_count)
# as these days dont have any event, day_start/end_at are None,
# and count is 0.
if (schedule_start_week > current_week
and (schedule_start_week - current_week) <= 2):
if (schedule_start_week - current_week) == 2:
# add this so that the next week's dates
# are also included in the calendar.
session_dates.insert(
0, (now + timedelta(days=7), None, None, 0))
session_dates.insert(0, (now, None, None, 0))
weeks = defaultdict(dict)
today = now.date()
for project_date, _day_start_at, _day_end_at, session_count in session_dates:
weekobj = Week.withdate(project_date)
if weekobj.week not in weeks:
weeks[weekobj.week]['year'] = weekobj.year
# Order is important, and we need dict to count easily
weeks[weekobj.week]['dates'] = OrderedDict()
for wdate in weekobj.days():
weeks[weekobj.week]['dates'].setdefault(wdate, 0)
if project_date.date() == wdate:
# If the event is over don't set upcoming for current week
if wdate >= today and weekobj >= current_week and session_count > 0:
weeks[weekobj.week]['upcoming'] = True
weeks[weekobj.week]['dates'][wdate] += session_count
if 'month' not in weeks[weekobj.week]:
weeks[weekobj.week]['month'] = format_date(
wdate, 'MMM', locale=get_locale())
# Extract sorted weeks as a list
weeks_list = [v for k, v in sorted(weeks.items())]
for week in weeks_list:
# Convering to JSON messes up dictionary key order even though we used OrderedDict.
# This turns the OrderedDict into a list of tuples and JSON preserves that order.
week['dates'] = [{
'isoformat':
date.isoformat(),
'day':
format_date(date, 'd', get_locale()),
'count':
count,
'day_start_at':
(session_dates_dict[date]['day_start_at'].astimezone(
self.timezone).strftime('%I:%M %p')
if date in session_dates_dict.keys() else None),
'day_end_at':
(session_dates_dict[date]['day_end_at'].astimezone(
self.timezone).strftime('%I:%M %p %Z')
if date in session_dates_dict.keys() else None),
} for date, count in week['dates'].items()]
return {
'locale':
get_locale(),
'weeks':
weeks_list,
'today':
now.date().isoformat(),
'days': [
format_date(day, 'EEE', locale=get_locale())
for day in Week.thisweek().days()
],
}
#log('UKBot-uploader starting at %s (server time), %s (wiki time)' % (runstart.strftime('%F %T'), runstart.astimezone(wiki_tz).strftime('%F %T')))
host = config['homesite']
homesite = mwclient.Site(host)
now = server_tz.localize(datetime.now())
if args.page is not None:
ktitle = args.page.decode('utf-8')
else:
log(' No page specified. Using default page')
ktitle = config['pages']['default']
# subtract a few hours, so we close last week's contest right after midnight
#ktitle = (now - timedelta(hours=1)).astimezone(wiki_tz).strftime(ktitle.encode('utf-8')).decode('utf-8')
ktitle = config['pages']['default']
w = Week.withdate((now - timedelta(hours=3)).astimezone(wiki_tz).date())
# subtract one hour, so we close last week's contest right after midnight
ktitle = ktitle % {'year': w.year, 'week': w.week}
# Is ktitle redirect? Resolve
log('@ ktitle is %s' % ktitle)
pp = homesite.api('query', prop='pageprops', titles=ktitle, redirects='1')
if 'redirects' in pp['query']:
ktitle = pp['query']['redirects'][0]['to']
log(' -> Redirected to: %s' % ktitle)
kpage = homesite.pages[ktitle]
if not kpage.exists:
log(' !! kpage does not exist! Exiting')
sys.exit(0)
def week(self):
return Week.withdate(self.date).week
def format_week(date):
return Week.withdate(date).isoformat()
def getWeekFromDate(dateElement):
return Week.withdate(dateElement)
def done(self, form_list, **kwargs):
form_data = [form.cleaned_data for form in form_list]
customized = form_data[0].get('customized', False)
try:
thematic = models.Thematic.objects.select_related().get(id=self.kwargs.get('thematic_id', None))
except models.Thematic.DoesNotExist:
thematic = None
thematic_products = [e.product for e in thematic.thematicextent_set.all()] if thematic else []
products = {}
if customized:
for product in pm.Product.objects.select_related().all():
if ('product_%d' % product.id) in form_list[1].data:
products[product] = int(form_list[1].data['product_%d' % product.id])
else:
if thematic:
for e in thematic.thematicextent_set.all():
products[e.product] = e.extent
if not products:
raise forms.forms.ValidationError("no product was selected")
size = form_data[0].get('size')
carrier = form_data[0].get('carrier')
receive_only_once = form_data[0].get('receive_only_once', False)
frequency = int(form_data[0].get('frequency'))
duration = int(form_data[0].get('duration'))
bw = Week.fromstring(form_data[0].get('start'))
ew = Week.withdate( bw.day(1) + relativedelta(months=duration) )
customer = self.request.user.customer
criterias = form_data[0].get('criterias')
subscription = models.Subscription.objects.create(customer=customer, size=size, carrier=carrier, receive_only_once=receive_only_once, frequency=frequency, start=bw, end=ew)
subscription.criterias = criterias
for product, extent in products.items():
subscription.extent_set.create(product=product, extent=extent)
subscription.create_deliveries()
messages.success(self.request, _('The subscription was sucessfuly created.'))
deliveries = subscription.delivery_set.order_by('date')
mm.Message.objects.create_message(participants=[customer], subject=_('Votre abonnement %(subscription_id)d a été crée') % {'subscription_id': subscription.id}, body=_(
"""Bonjour %(name)s,
Nous sommes heureux de vous annoncer que votre abonnement %(subscription_id)d a été crée, il est accessible à l'adresse suivante :
http://www.vegeclic.fr/carts/subscriptions/%(subscription_id)d/deliveries/
Vous êtes invité, à présent, à approvisionner votre portemonnaie vers un solde suffisant afin que l'on valide la première échéance du %(date)s de votre abonnement en cliquant sur le lien suivant :
http://www.vegeclic.fr/wallets/credit/
Si ce n'est pas encore fait, merci de bien vouloir renseigner vos cordonnées à cette adresse :
http://www.vegeclic.fr/customers/addresses/create/
Bien cordialement,
Végéclic.
"""
) % {'name': customer.main_address.__unicode__() if customer.main_address else '', 'date': deliveries[0].get_date_display(), 'subscription_id': subscription.id})
return HttpResponseRedirect('/carts/subscriptions/%d/deliveries/page/1' % subscription.id)
def add_significant_date(self, sig_date, note):
key = Week.withdate(sig_date)
week = self._weeks[key]
week.add_significant_date(note)
print("Updated w/b {0} with {1}".format(key.monday(), note))
def get_week_from_date(date):
return Week.withdate(date)
reader = csv.DictReader(open("/Users/rodrigo.abreu/Downloads/incident.csv"))
for inc in reader:
weekly_incidents(inc)
open_dates.append(dt.datetime.strptime(inc['opened_at'], '%Y-%m-%d %H:%M:%S'))
if inc['closed_at']: # not counting open incidents
resolution_times.append(dt.datetime.strptime(inc['closed_at'], '%Y-%m-%d %H:%M:%S') -
dt.datetime.strptime(inc['opened_at'], '%Y-%m-%d %H:%M:%S'))
statistics = mttr_mtbf()
print statistics['mtbf'].days, statistics['mtbf'].seconds//3600
print statistics['mttr'].days, statistics['mttr'].seconds//3600
print "INC/day: ", (reader.line_num - 1)/180
start_week = Week.withdate(date(2014, 06, 01))
end_week = Week.withdate(date(2014, 11, 30))
print "INC/Week: ", (reader.line_num - 1)/(end_week-start_week)
print incs_by_week
# with open('/Users/rodrigo.abreu/Downloads/incident.csv', 'rb') as csvfile:
# # spamreader = csv.reader(csvfile, delimiter=',', quotechar='"')
# # for row in spamreader:
# # print ', '.join(row)
# reader = csv.DictReader(csvfile)
# open_date = []
# resolution_time = []
# incs_by_week = {}
def week_no(y, m, d):
quarter_start_date = datetime.date(y, m, d)
return Week.withdate(quarter_start_date)
def test_withdate_uses_monday_as_start_of_week(self):
from datetime import date
self.assertEqual(str(Week.withdate(date(2014, 12, 29))), "2014W52")
self.assertEqual(str(Week.withdate(date(2014, 12, 30))), "2014W52")
self.assertEqual(str(Week.withdate(date(2014, 12, 31))), "2014W52")
self.assertEqual(str(Week.withdate(date(2015, 1, 1))), "2014W52")
self.assertEqual(str(Week.withdate(date(2015, 1, 2))), "2014W52")
self.assertEqual(str(Week.withdate(date(2015, 1, 3))), "2014W52")
self.assertEqual(str(Week.withdate(date(2015, 1, 4))), "2014W52")
self.assertEqual(str(Week.withdate(date(2015, 1, 5))), "2015W01")
self.assertEqual(str(Week.withdate(date(2015, 1, 6))), "2015W01")
self.assertEqual(str(Week.withdate(date(2015, 1, 7))), "2015W01")
self.assertEqual(str(Week.withdate(date(2015, 1, 8))), "2015W01")
self.assertEqual(str(Week.withdate(date(2015, 1, 9))), "2015W01")
self.assertEqual(str(Week.withdate(date(2015, 1, 10))), "2015W01")
self.assertEqual(str(Week.withdate(date(2015, 1, 11))), "2015W01")
self.assertEqual(str(Week.withdate(date(2015, 1, 12))), "2015W02")
def weeks(start: date, end: date) -> Iterator[Week]:
for week in range(
Week.withdate(start).toordinal(),
Week.withdate(end).toordinal() + 1):
yield Week.fromordinal(week)
def handle_noargs(self, **options):
translation.activate('fr')
logging.debug('Command in progress')
pop_size = 50
max_gen = 50
lambda_algo = 100
cxpb = .7
mutpb = .2
min_quantity = 0
max_quantity = 2
margin = .1
zero = True
debug = False
if debug: logging.debug('DEBUG MODE')
week_limit = Week.withdate(Week.thisweek().day(setting.VALIDATING_DAY_OF_WEEK) + relativedelta(days=settings.DELAY_BETWEEN_DEFINITON_N_DELIVERY))
deliveries = models.Delivery.objects.filter(date__lte=week_limit, status='p', subscription__enabled=True)
for delivery in deliveries:
logging.debug(delivery.__unicode__())
subscription = delivery.subscription
subscription_weight = subscription.size.weight - subscription.size.weight*settings.PACKAGING_WEIGHT_RATE/100
subscription_price = subscription.price().price
carrier = subscription.carrier
weight_level = carrier.carrierlevel_set.filter(weight__gte=subscription.size.weight)
if weight_level:
logging.debug('weight_level: %s kg (%s €)' % (weight_level[0].weight, weight_level[0].price))
subscription_price -= weight_level[0].price
logging.debug('carrier: %s' % carrier.name)
logging.debug('subscription_weight: %s kg' % subscription_weight)
logging.debug('subscription_price: %s € (%s €)' % (subscription_price, subscription.price().price))
for extent in subscription.extent_set.all():
__extent = extent.extent
logging.debug('meta-product: %s, extent: %s' % (extent.product.name, __extent))
if extent.customized:
logging.debug("start fullfilling the delivery cart with a custom content")
logging.debug("create custom content object")
content = delivery.content_set.create(product=extent.product, extent=extent.extent, customized=extent.customized) if not debug else None
extent_content = extent.extentcontent_set.get()
for ecp in extent_content.extentcontentproduct_set.all():
logging.debug("add product %s (%d) with a quantity %d (price: %s, weight: %s)" % (ecp.product.name, ecp.product.id, ecp.quantity, ecp.product.price().__unicode__(), ecp.product.weight))
if not debug:
content.contentproduct_set.create(product=ecp.product, quantity=ecp.quantity)
continue
def get_product_products(product):
__products = []
for child in product.products_children.all():
__products += get_product_products(child)
__products += product.product_product.filter(status='p').all()
return __products
products = get_product_products(extent.product)
nbr_items = len(products)
prices = [p.main_price.get_after_tax_price_with_fee() if carrier.apply_suppliers_fee else p.main_price.get_after_tax_price() for p in products]
weights = [int(p.weight) for p in products]
criterias = []
if subscription.criterias.all():
for p in products:
__filter = p.criterias
for c in subscription.criterias.filter(enabled=True).all():
__filter = __filter.filter(id=c.id)
criterias.append(len(__filter.all()))
else:
criterias = [0] * nbr_items
total_price = round(subscription_price*__extent/100, 2)
total_weight = round(subscription_weight*__extent/100*1000, 2)
total_criteria = round(sum(criterias), 2)
from deap import algorithms, base, creator, tools
pareto = tools.selNSGA2
# pareto = tools.selSPEA2
algo = algorithms.eaMuPlusLambda
# algo = algorithms.eaMuCommaLambda
creator.create("Fitness", base.Fitness, weights=(-1.0,-1.0,-1.0,-1.0,))
creator.create("Individual", list, fitness=creator.Fitness)
toolbox = base.Toolbox()
if zero:
toolbox.register("quantity_item", lambda: min_quantity)
else:
toolbox.register("quantity_item", random.randint, min_quantity, max_quantity)
toolbox.register("individual", tools.initRepeat, creator.Individual,
toolbox.quantity_item, nbr_items)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
def eval(individual):
eval_total_price = 0.0
eval_total_weight = 0.0
eval_total_criteria = 0.0
for i in range(nbr_items):
eval_total_price += individual[i] * prices[i]
eval_total_weight += individual[i] * weights[i]
eval_total_criteria += individual[i] * criterias[i]
return \
abs(total_price - eval_total_price),\
abs(total_criteria - eval_total_criteria),\
plt.mlab.entropy(individual, 1),\
abs(total_weight - eval_total_weight),\
# def cx(ind1, ind2): return tools.crossover.cxOnePoint(ind1, ind2)
# def mut(individual): return tools.mutation.mutUniformInt(individual, min_quantity, max_quantity, 0.01)
def cx(ind1, ind2):
site = random.randint(0, min(len(ind1), len(ind2)))
ind1[:site], ind2[:site] = ind2[:site], ind1[:site]
return ind1, ind2
def mut(individual):
pos = random.randint(0, nbr_items-1)
individual[pos] = random.randint(min_quantity, max_quantity)
return individual,
toolbox.register("evaluate", eval)
toolbox.register("mate", cx)
toolbox.register("mutate", mut)
toolbox.register("select", pareto)
pop = toolbox.population(n=pop_size)
hof = tools.ParetoFront()
new_pop, logbook = algo(pop, toolbox, pop_size, lambda_algo, cxpb, mutpb, max_gen, halloffame=hof, verbose=0)
logging.debug("len(hof): %d" % len(hof))
logging.debug("len(products): %s" % len(products))
logging.debug("prices (€): %s" % prices)
logging.debug("weights (g): %s" % weights)
logging.debug("criterias: %s" % criterias)
logging.debug("total_price: %f €" % total_price)
logging.debug("total_weight: %f g" % total_weight)
logging.debug("total_criteria: %f" % total_criteria)
margin_hof = []
for m in np.arange(margin, 1, margin):
logging.debug("trial margin hof with %.2f", m)
trial_margin_hof = []
for x in hof:
if x.fitness.values[0] <= (total_price*m): trial_margin_hof.append(x)
if len(trial_margin_hof) > 0:
margin_hof = trial_margin_hof
break
assert len(margin_hof) > 0
sorted = np.sort(np.array([(i,) + x.fitness.values for i, x in enumerate(margin_hof)],
dtype=[('i', int), ('price', float), ('criterias', float),
('diversity', float), ('weight', float)]),
order=['criterias', 'diversity', 'weight', 'price'])
sol = hof[ sorted[0][0] ]
logging.debug("sol: %s" % sol)
logging.debug("sol.fitness: %s" % sol.fitness)
assert len(sol) == nbr_items
logging.debug("start fullfilling the delivery cart content")
logging.debug("create content object")
content = delivery.content_set.create(product=extent.product, extent=extent.extent, customized=extent.customized) if not debug else None
for i in range(nbr_items):
if sol[i]:
logging.debug("add product %s (%d - %d) with a quantity %d (price: %f, weight: %f)" % (products[i].name, i, products[i].id, sol[i], prices[i], weights[i]))
if not debug:
content.contentproduct_set.create(product=products[i], quantity=sol[i])
if not debug:
logging.debug("change delivery status")
delivery.status = 'P'
delivery.save()
logging.debug("send a message to the delivery customer")
customer = subscription.customer
message = mm.Message.objects.create_message(participants=[customer], subject=_('Delivery %(date)s is in progress') % {'date': delivery.get_date_display()}, body=_(
"""Hi %(name)s,
we are pleased to announce your delivery %(date)s content from the subscription %(subscription_id)d has been defined and will be prepared as soon as possible for sending.
Your cart will be send to you in 10 days.
Best regards,
Végéclic.
"""
) % {'name': customer.main_address.__unicode__() if customer.main_address else '', 'date': delivery.get_date_display(), 'subscription_id': subscription.id})
translation.deactivate()
def handle_noargs(self, **options):
translation.activate('fr')
logging.debug('Command in progress')
self.print_interactive_usage()
if options['test']:
logging.info('[TEST MODE enabled]')
logging.info('')
week_limit = Week.withdate(Week.thisweek().day(settings.VALIDATING_DAY_OF_WEEK) + relativedelta(days=settings.DELAY_BETWEEN_DEFINITON_N_DELIVERY))
deliveries = models.Delivery.objects.filter(date__lte=week_limit, status='p', subscription__enabled=True)
logging.info('Number of deliveries to fullfill: %d' % deliveries.count())
for delivery in deliveries:
logger_delivery = logging.getLogger('[delivery %d]' % delivery.id)
logger_delivery.info('')
logger_delivery.info('Process the delivery: %s' % delivery.__unicode__())
logger_delivery.info('')
subscription = delivery.subscription
subscription_weight = subscription.size.weight - subscription.size.weight*settings.PACKAGING_WEIGHT_RATE/100
subscription_price = subscription.price().price
carrier = subscription.carrier
weight_level = carrier.carrierlevel_set.filter(weight__gte=subscription.size.weight)
if weight_level:
logger_delivery.info('weight level:\t\t%s kg (%s €)' % (weight_level[0].weight, weight_level[0].price))
subscription_price -= weight_level[0].price
logger_delivery.info('carrier:\t\t%s' % carrier.name)
logger_delivery.info('subscription weight:\t%s kg' % subscription_weight)
logger_delivery.info('subscription price:\t%s € (%s €)' % (subscription_price, subscription.price().price))
logger_delivery.info('')
for extent in subscription.extent_set.all():
__extent = extent.extent
logger_extent = logging.getLogger('[delivery %d] [%s] [%s%%]' % (delivery.id, extent.product.name, __extent))
logger_extent.debug('meta-product: %s, extent: %s' % (extent.product.name, __extent))
if extent.customized:
logger_extent = logging.getLogger('[delivery %d] [%s] [%s%%] [custom]' % (delivery.id, extent.product.name, __extent))
logger_extent.info('start fullfilling the delivery cart with a custom content')
logger_extent.info('create custom content object')
content = delivery.content_set.create(product=extent.product, extent=extent.extent, customized=extent.customized) if not options['test'] else None
extent_content = extent.extentcontent_set.get()
for ecp in extent_content.extentcontentproduct_set.all():
logger_extent.info('+ %d x %30s\t\t(%d,\t%s€,\t%sg)' % (ecp.quantity, ecp.product.name[:30], ecp.product.id, ecp.product.price().__unicode__(), ecp.product.weight))
if not options['test']:
content.contentproduct_set.create(product=ecp.product, quantity=ecp.quantity)
continue
def get_product_products(product):
__products = []
for child in product.products_children.all():
__products += get_product_products(child)
__products += product.product_product.filter(status='p').all()
return __products
products = get_product_products(extent.product)
nbr_items = len(products)
prices = [p.main_price.get_after_tax_price_with_fee() if carrier.apply_suppliers_fee else p.main_price.get_after_tax_price() for p in products]
weights = [int(p.weight or settings.DEFAULT_WEIGHT) for p in products]
criterias = []
if subscription.criterias.all():
for p in products:
__filter = p.criterias
for c in subscription.criterias.filter(enabled=True).all():
__filter = __filter.filter(id=c.id)
criterias.append(len(__filter.all()))
else:
criterias = [0] * nbr_items
total_price = round(subscription_price*__extent/100, 2)
total_weight = round(subscription_weight*__extent/100*1000, 2)
total_criteria = round(sum(criterias), 2)
creator.create("Fitness", base.Fitness, weights=(-1.0,-1.0,-1.0,-1.0,))
creator.create("Individual", list, fitness=creator.Fitness)
toolbox = base.Toolbox()
if options['zero']:
toolbox.register("quantity_item", lambda: options['min_quantity'])
else:
toolbox.register("quantity_item", random.randint, options['min_quantity'], options['max_quantity'])
toolbox.register("individual", tools.initRepeat, creator.Individual,
toolbox.quantity_item, nbr_items)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
def eval(individual):
eval_total_price = 0.0
eval_total_weight = 0.0
eval_total_criteria = 0.0
for i in range(nbr_items):
eval_total_price += individual[i] * prices[i]
eval_total_weight += individual[i] * weights[i]
eval_total_criteria += individual[i] * criterias[i]
return \
abs(total_price - eval_total_price),\
abs(total_criteria - eval_total_criteria),\
plt.mlab.entropy(individual, 1),\
abs(total_weight - eval_total_weight),\
# def cx(ind1, ind2): return tools.crossover.cxOnePoint(ind1, ind2)
# def mut(individual): return tools.mutation.mutUniformInt(individual, options['min_quantity'], options['max_quantity'], 0.01)
def cx(ind1, ind2):
site = random.randint(0, min(len(ind1), len(ind2)))
ind1[:site], ind2[:site] = ind2[:site], ind1[:site]
return ind1, ind2
def mut(individual):
pos = random.randint(0, nbr_items-1)
individual[pos] = random.randint(options['min_quantity'], options['max_quantity'])
return individual,
pareto = tools.selNSGA2 if options['pareto'] else tools.selSPEA2
algo = algorithms.eaMuPlusLambda if options['algo'] else algorithms.eaMuCommaLambda
toolbox.register("evaluate", eval)
toolbox.register("mate", cx)
toolbox.register("mutate", mut)
toolbox.register("select", pareto)
pop = toolbox.population(n=options['pop_size'])
hof = tools.ParetoFront()
new_pop, logbook = algo(pop, toolbox, options['pop_size'], options['lambda_algo'], options['cxpb'], options['mutpb'], options['max_gen'], halloffame=hof, verbose=0)
logger_extent.debug("len(hof): %d" % len(hof))
logger_extent.debug("len(products): %s" % len(products))
logger_extent.debug("prices (€): %s" % prices)
logger_extent.debug("weights (g): %s" % weights)
logger_extent.debug("criterias: %s" % criterias)
logger_extent.debug("total_price: %f €" % total_price)
logger_extent.debug("total_weight: %f g" % total_weight)
logger_extent.debug("total_criteria: %f" % total_criteria)
margin_hof = []
for m in np.arange(options['margin'], 1, options['margin']):
logger_extent.debug("trial margin hof with %.2f", m)
trial_margin_hof = []
for x in hof:
if x.fitness.values[0] <= (total_price*m): trial_margin_hof.append(x)
if len(trial_margin_hof) > 0:
margin_hof = trial_margin_hof
break
assert len(margin_hof) > 0
sorted = np.sort(np.array([(i,) + x.fitness.values for i, x in enumerate(margin_hof)],
dtype=[('i', int), ('price', float), ('criterias', float),
('diversity', float), ('weight', float)]),
order=['criterias', 'diversity', 'weight', 'price'])
logger_extent.info('there are %d solutions' % len(sorted))
for i, fitnesses in enumerate(sorted):
logger_solution = logging.getLogger('[delivery %d] [%s] [%s%%] [%d]' % (delivery.id, extent.product.name, __extent, i))
sol = hof[ fitnesses[0] ]
logger_solution.info('')
logger_solution.debug('sol: %s' % sol)
logger_solution.info('sol.fitness: %s' % sol.fitness)
assert len(sol) == nbr_items
for i in range(nbr_items):
if sol[i]:
logger_solution.info('+ %d x %30s\t(%d,\t%s€,\t%sg)' % (sol[i], products[i].name[:30], products[i].id, prices[i], weights[i]))
idx = 0
higherbound = len(sorted)-1
while True:
try:
idx = int(input('[Select one solution between 0 and %d]$ ' % higherbound))
except TypeError:
logger_extent.error('Bad type value passed (a value between 0 and %d)' % higherbound)
except ValueError:
logger_extent.error('Bad value passed (a value between 0 and %d)' % higherbound)
else:
if 0 <= idx < higherbound+1: break
logger_extent.info('Start fullfilling the delivery cart content with the solution %d' % idx)
sol = hof[ sorted[idx][0] ]
logger_extent.info('Create content object')
content = delivery.content_set.create(product=extent.product, extent=extent.extent, customized=extent.customized) if not options['test'] else None
for i in range(nbr_items):
if sol[i]:
logger_extent.info('+ %d x %30s\t(%d,\t%s€,\t%sg)' % (sol[i], products[i].name[:30], products[i].id, prices[i], weights[i]))
if not options['test']:
content.contentproduct_set.create(product=products[i], quantity=sol[i])
if not options['test']:
logger_extent.info("change delivery status")
delivery.status = 'P'
delivery.save()
logger_extent.info("send a message to the delivery customer")
customer = subscription.customer
message = mm.Message.objects.create_message(participants=[customer], subject=_('Delivery %(date)s is in progress') % {'date': delivery.get_date_display()}, body=_(
"""Hi %(name)s,
we are pleased to announce your delivery %(date)s content from the subscription %(subscription_id)d has been defined and will be prepared as soon as possible for sending.
Your cart will be send to you in 10 days.
Best regards,
Végéclic.
"""
) % {'name': customer.main_address.__unicode__() if customer.main_address else '', 'date': delivery.get_date_display(), 'subscription_id': subscription.id})
translation.deactivate()
for inc in reader:
weekly_incidents(inc)
open_dates.append(
dt.datetime.strptime(inc['opened_at'], '%Y-%m-%d %H:%M:%S'))
if inc['closed_at']: # not counting open incidents
resolution_times.append(
dt.datetime.strptime(inc['closed_at'], '%Y-%m-%d %H:%M:%S') -
dt.datetime.strptime(inc['opened_at'], '%Y-%m-%d %H:%M:%S'))
statistics = mttr_mtbf()
print statistics['mtbf'].days, statistics['mtbf'].seconds // 3600
print statistics['mttr'].days, statistics['mttr'].seconds // 3600
print "INC/day: ", (reader.line_num - 1) / 180
start_week = Week.withdate(date(2014, 06, 01))
end_week = Week.withdate(date(2014, 11, 30))
print "INC/Week: ", (reader.line_num - 1) / (end_week - start_week)
print incs_by_week
# with open('/Users/rodrigo.abreu/Downloads/incident.csv', 'rb') as csvfile:
# # spamreader = csv.reader(csvfile, delimiter=',', quotechar='"')
# # for row in spamreader:
# # print ', '.join(row)
# reader = csv.DictReader(csvfile)
# open_date = []
# resolution_time = []
# incs_by_week = {}
# count = 0
# for row in reader:
# #print(row['number'],
