Expert Overview

The upcoming match between Botosani and Universitatea Craiova promises to be a thrilling encounter with high stakes for both teams. As indicated by the odds, this match is expected to be goal-rich, with a high likelihood of both teams finding the back of the net. The average total goals are projected at 4.28, suggesting an aggressive and open game. Furthermore, there is a significant probability of goals occurring late in the match, particularly in the last 15 and 10 minutes, which could add an extra layer of excitement and unpredictability.

Prediction: Away Team To Score In 2nd Half

The odds for Universitatea Craiova scoring in the second half are quite favorable at 97.50, indicating that bettors expect them to capitalize on their attacking prowess later in the game. This could be due to anticipated fatigue from Botosani or strategic adjustments made by the away team during halftime.

Prediction: Away Team To Score In 1st Half

With odds of 98.20, there’s a strong belief that Universitatea Craiova will score in the first half. This suggests that they might come out aggressively from the start, aiming to take an early lead.

Prediction: Home Team To Score In 2nd Half

Botosani has slightly better odds at 98.60 for scoring in the second half, indicating a balanced expectation that they will respond to any early goals conceded and push for a comeback or equalizer.

Prediction: Over 1.5 Goals

The odds for over 1.5 goals stand at 89.00, reinforcing the expectation of a high-scoring affair. This aligns with the predicted average total goals of 4.28.

Prediction: First Goal Between Minute 0-29

With odds of 89.50, there is a strong likelihood that the first goal will be scored within the first half-hour of play, suggesting an early offensive push from either side.

Prediction: Over 4.5 Cards

The odds for over 4.5 cards being issued are at 89.60, indicating a potentially intense match with physical confrontations and possible disciplinary actions.

Prediction: Both Teams Not To Score In 1st Half

At odds of 85.80, there’s a moderate expectation that neither team will score in the first half, possibly due to cautious play or strong defensive setups early on.

Prediction: Over 2.5 Goals

The odds for over 2.5 goals are set at 76.80, suggesting that bettors anticipate a lively match with multiple scoring opportunities.

Prediction: Both Teams To Score

With odds of 74.10, there is a good chance that both teams will manage to score during the match, reflecting their offensive capabilities and the open nature of the game.

Prediction: Home Team To Score In 1st Half

Botosani has odds of 76.70 for scoring in the first half, indicating a balanced expectation that they will make an early impact on the scoreboard.

Prediction: Over 5.5 Cards

The odds for over 5.5 cards are at 74.40, suggesting that tempers may flare and result in numerous bookings throughout the match.

Prediction: Both Teams To Score In 2nd Half

At odds of 70.20, there is a strong belief that both teams will score in the second half, likely as part of a dynamic and competitive second period.

Prediction: Over 2.5 BTTS (Both Teams To Score)

The odds for over 2.5 BTTS are at 61.30, indicating an expectation for both teams to score multiple times throughout the match.

Prediction: Over 3.5 Goals

With odds of 64.40, there is anticipation for a high-scoring game with more than three goals likely to be scored by both teams combined.

Prediction: Goal In Last 15 Minutes

The odds for a goal being scored in the last quarter-hour are at 52.80, highlighting potential dramatic late-game developments.

Prediction: Goal In Last 10 Minutes

benjamin-lu/lastrun/README.md
# Lastrun

## Requirements
* Python3
* BeautifulSoup4
* requests

## Setup

pip3 install beautifulsoup4 requests

## Run

python3 lastrun.py

## Features

* Show last run time
* List all runs ever done
* Show number of runs per week/month/year

## Todo

* Get rid of global variables (they’re nasty)
* Make it more like a CLI app
* ~~Fix issue with multiple runs on same day~~
* ~~Add option to print all runs~~
* ~~Add option to print run count per week/month/year~~benjamin-lu/lastrun/lastrun.py
#!/usr/bin/python3

import requests
from bs4 import BeautifulSoup as bs

# my profile URL
profile_url = “https://www.strava.com/athletes/191424”

# global vars
last_run = None
all_runs = []

def get_soup(url):
r = requests.get(url)
return bs(r.text)

def parse_runs(soup):
global all_runs

# get table rows from results page
trs = soup.select(“table.list tr”)

# skip first row (table header)
trs.pop(0)

# iterate through each table row (run)
for tr in trs:
# get columns from each row
tds = tr.select(“td”)

# get run name from first column (this can contain links so use text instead)
run_name = tds[0].text.strip()

# get run date/time from second column (this can contain links so use text instead)
date_time = tds[1].text.strip()

# add run to all runs list if not already added
if not any(r[“name”] == run_name for r in all_runs):
all_runs.append({
“name”: run_name,
“date_time”: date_time,
})

def print_last_run():
print(f”Last run was {last_run[‘date_time’]} ({last_run[‘name’]})”)

def print_all_runs():
print(“All runs:”)
for r in all_runs:
print(f”{r[‘date_time’]} ({r[‘name’]})”)

def print_run_count_by_period():
periods = {
“days”: {},
“weeks”: {},
“months”: {},
“years”: {},
}

def increment_period(periods_dict):
today = datetime.today()
key = str(today.year) + “-” + str(today.month) + “-” + str(today.day)

if key not in periods_dict:
periods_dict[key] = {“count”:0}

periods_dict[key][“count”] +=1

def add_to_period(periods_dict):
today = datetime.today()

if period == “days”:
key = str(today.year) + “-” + str(today.month) + “-” + str(today.day)

elif period == “weeks”:
key = str(today.isocalendar()[0]) + “-” + str(today.isocalendar()[1])

elif period == “months”:
key = str(today.year) + “-” + str(today.month)

elif period == “years”:
key = str(today.year)

if key not in periods_dict:
periods_dict[key] = {“count”:0}

periods_dict[key][“count”] +=1

def print_period(periods_dict):
keys = sorted(periods_dict.keys(), reverse=True)

print(f”Total {len(keys)} {period}{‘s’ if len(keys) >1 else ”}”)

for k in keys:
count = periods_dict[k][“count”]
print(f”{k}: {count}”)

for r in all_runs:

date_time_str = r[“date_time”]

dt_obj = datetime.strptime(date_time_str[:10], ‘%Y-%m-%d’)

if last_run[“date_time”][:10] == dt_obj.strftime(‘%Y-%m-%d’):
increment_period(periods[“days”])

if last_run[“date_time”][:7] == dt_obj.strftime(‘%Y-%m’):
increment_period(periods[“months”])

if last_run[“date_time”][:4] == dt_obj.strftime(‘%Y’):
increment_period(periods[“years”])

add_to_period(periods[“days”])
add_to_period(periods[“weeks”])
add_to_period(periods[“months”])
add_to_period(periods[“years”])

print(“Runs by day:”)
print_period(periods[“days”])

print(“Runs by week:”)
print_period(periods[“weeks”])

print(“Runs by month:”)
print_period(periods[“months”])

print(“Runs by year:”)
print_period(periods[“years”])

# main program logic

# get html from profile url
soup = get_soup(profile_url)

# find results link
results_link = soup.select_one(“#athlete .nav-link[href$=’activities’]”)

# get url to results page
results_url = results_link[‘href’]

# get html from results page url
soup_results_page = get_soup(results_url)

# parse runs from results page
parse_runs(soup_results_page)

# sort runs by date/time desc
all_runs.sort(key=lambda x:x[‘date_time’], reverse=True)

# set last run
last_run = all_runs[0]

print_last_run()
print_all_runs()
print_run_count_by_period()# -*- coding:utf-8 -*-

import json

from django.core.exceptions import ObjectDoesNotExist

from rest_framework import status as http_status
from rest_framework.views import APIView
from rest_framework.response import Response

class BaseAPIView(APIView):

def get_object(self):

try:
return self.model.objects.get(pk=self.kwargs.get(‘pk’))

except ObjectDoesNotExist:

return None

class ListCreateAPIView(BaseAPIView):

def post(self,request,*args,**kwargs):

data=json.loads(request.body.decode())

try:

obj=self.model(**data)

obj.save()

return Response(data=obj.serialize(),status=http_status.HTTP_201_CREATED)

except Exception as e:

return Response(data={
‘message’:e.message,
‘error’:e.__class__.__name__
},
status=http_status.HTTP_400_BAD_REQUEST
)

class RetrieveUpdateDestroyAPIView(BaseAPIView):

def put(self,request,*args,**kwargs):

data=json.loads(request.body.decode())

obj=self.get_object()

try:

for attr,value in data.items():

setattr(obj , attr , value)

obj.save()

return Response(data=obj.serialize(),status=http_status.HTTP_200_OK)

except Exception as e:

return Response(data={
‘message’:e.message,
‘error’:e.__class__.__name__
},
status=http_status.HTTP_400_BAD_REQUEST
)

mechouf/projet_tuto_django_rest_api/rest_api/books/urls.py
from django.conf.urls import url

from .views import (
BookListCreateAPIView,
BookRetrieveUpdateDestroyAPIView,
)

urlpatterns=[
url(r’^books/$’,BookListCreateAPIView.as_view()),
url(r’^books/(?P[0-9]+)/$’,BookRetrieveUpdateDestroyAPIView.as_view())
]# -*- coding:utf-8 -*-

from django.db import models

class Book(models.Model):

title=models.CharField(max_length=100,null=False)
author=models.CharField(max_length=100,null=False)
publisher=models.CharField(max_length=100,null=False)
published_date=models.DateField(null=False)
pages=models.IntegerField(null=False,default=0)

def serialize(self):

data={
‘id’:self.id,
‘title’:self.title,
‘author’:self.author,
‘publisher’:self.publisher,
‘published_date’:self.published_date.isoformat(),
‘pages’:self.pages,
}

return datamechouf/projet_tuto_django_rest_api/rest_api/books/views.py
from django.shortcuts import render

from .models import Book

from .serializers import BookSerializer

from rest_framework.generics import (
ListCreateAPIView,
RetrieveUpdateDestroyAPIView)

class BookListCreateAPIView(ListCreateAPIView):

queryset=Book.objects.all()

serializer_class=BookSerializer

class BookRetrieveUpdateDestroyAPIView(RetrieveUpdateDestroyAPIView):

queryset=Book.objects.all()

serializer_class=BookSerializer

# -*- coding:utf-8 -*-

from rest_framework import serializers

from books.models import Book

class BookSerializer(serializers.ModelSerializer):

class Meta:

model=Book

fields=(
‘id’,
‘title’,
‘author’,
‘publisher’,
‘published_date’,
‘pages’
)# -*- coding:utf-8 -*-

import json

from django.test import TestCase

from rest_framework.test import APIClient

from books.models import Book

class TestBooksAPI(TestCase):

fixtures=[
‘test_books.json’
]

def setUp(self):

self.client=APIClient()

def test_get_books(self):

response=self.client.get(‘/books/’)

books=response.data

self.assertEqual(len(books),len(Book.objects.all()))

def test_create_book(self):

payload={
‘title’:’a new book’,
‘author’:’a new author’,
‘publisher’:’a new publisher’,
‘published_date’:’2016-11-11′,
‘pages’:12345,
}

response=self.client.post(‘/books/’,json.dumps(payload),content_type=’application/json’)

self.assertEqual(response.status_code ,200)

self.assertEqual(Book.objects.count() , len(Book.objects.all())+1)

def test_update_book(self):

payload={
‘title’:’updated book’,
‘author’:’updated author’,
‘publisher’:’updated publisher’,
‘published_date’:’2016-11-11′,
‘pages’:12345,
}

book=Book.objects.first()

response=self.client.put(‘/books/’+str(book.id)+’/’,json.dumps(payload),content_type=’application/json’)

self.assertEqual(response.status_code ,200)

deyvison13/generator-hubspot-ui-components/generators/app/templates/src/components/Button/Button.stories.tsx
import React from “react”;
import { Button } from “./Button”;

export default {
title: “Button”,
component: Button,
};

const Template = args => (

);

export const PrimaryVariantPrimaryColor = Template.bind({});
PrimaryVariantPrimaryColor.args = {
variant: “primary”,
color: “primary”,
};

export const PrimaryVariantSecondaryColor = Template.bind({});
PrimaryVariantSecondaryColor.args = {
variant: “primary”,
color: “secondary”,
};

export const PrimaryVariantTertiaryColor = Template.bind({});
PrimaryVariantTertiaryColor.args = {
variant: “primary”,
color: “tertiary”,
};

export const PrimaryVariantDestructiveColor = Template.bind({});
PrimaryVariantDestructiveColor.args = {
variant: “primary”,
color: “destructive”,
};

export const PrimaryVariantQuaternaryColor = Template.bind({});
PrimaryVariantQuaternaryColor.args = {
variant: “primary”,
color: “quaternary”,
};

export const PrimaryVariantSuccessColor = Template.bind({});
PrimaryVariantSuccessColor.args = {
variant: “primary”,
color: “success”,
};

export const PrimaryVariantWarningColor = Template.bind({});
PrimaryVariantWarningColor.args = {
variant: “primary”,
color: “warning”,
};

export const PrimaryVariantInfoColor = Template.bind({});
PrimaryVariantInfoColor.args = {
variant: “primary”,
color: “info”,
};

export const PrimaryVariantDisabledColor = Template.bind({});
PrimaryVariantDisabledColor.args = {
variant: “primary”,
color: “disabled”,
};