def test_locale():
dt = pendulum.datetime(2000, 11, 10, 12, 34, 56, 123456)
pendulum.set_locale("fr")
assert pendulum.get_locale() == "fr"
assert dt.format("MMMM") == "novembre"
assert dt.date().format("MMMM") == "novembre"
def test_locale():
dt = pendulum.datetime(2000, 11, 10, 12, 34, 56, 123456)
pendulum.set_locale('fr')
assert pendulum.get_locale() == 'fr'
assert dt.format('MMMM') == 'novembre'
assert dt.date().format('MMMM') == 'novembre'
def tearDown(self):
pendulum.set_test_now()
pendulum.set_formatter()
pendulum.set_locale('en')
LocalTimezone.set_local_timezone()
Pendulum.reset_to_string_format()
Date.reset_to_string_format()
Time.reset_to_string_format()
Pendulum.set_transition_rule(Timezone.POST_TRANSITION)
def __init__(self, token, debug=False):
self._token = token
self._updater = Updater(token)
self._debug = debug
self._session = requests.Session()
self._init_handlers()
pendulum.set_locale('ru')
def setup():
pendulum.set_local_timezone(pendulum.timezone("America/Toronto"))
yield
pendulum.set_test_now()
pendulum.set_locale("en")
pendulum.set_local_timezone()
pendulum.week_starts_at(pendulum.MONDAY)
pendulum.week_ends_at(pendulum.SUNDAY)
def setup():
pendulum.set_local_timezone(pendulum.timezone("America/Toronto"))
yield
pendulum.set_test_now()
pendulum.set_locale("en")
pendulum.set_local_timezone()
pendulum.week_starts_at(pendulum.MONDAY)
pendulum.week_ends_at(pendulum.SUNDAY)
def get_period_full_label(periodo: str) -> str:
"""Funcion que regresa el mes y el año en la siguiente forma
(Enero 2020)
"""
pendulum.set_locale('es')
year, month = explode(periodo)
if year and month:
date = pendulum.datetime(year=year, month=month, day=1)
return str(date.format('MMMM.YYYY')).replace('.', ' ').capitalize()
else:
return None
def test_set_locale_is_global(self):
dt = pendulum.create(2000, 11, 10, 12, 34, 56, 123456)
pendulum.set_formatter('alternative')
pendulum.set_locale('fr')
self.assertEqual(pendulum.Pendulum.get_locale(), 'fr')
self.assertEqual(pendulum.Date.get_locale(), 'fr')
self.assertEqual(pendulum.Time.get_locale(), 'fr')
self.assertEqual(dt.format('MMMM'), 'novembre')
self.assertEqual(dt.date().format('MMMM'), 'novembre')
def test_set_locale_can_be_overridden(self):
dt = pendulum.create(2000, 11, 10, 12, 34, 56, 123456)
pendulum.set_formatter('alternative')
pendulum.set_locale('fr')
pendulum.Pendulum.set_locale('en')
pendulum.Date.set_locale('en')
pendulum.Time.set_locale('en')
self.assertEqual(pendulum.Pendulum.get_locale(), 'en')
self.assertEqual(pendulum.Date.get_locale(), 'en')
self.assertEqual(pendulum.Time.get_locale(), 'en')
self.assertEqual(dt.format('MMMM'), 'November')
self.assertEqual(dt.date().format('MMMM'), 'November')
def test_set_locale_invalid():
with pytest.raises(ValueError):
pendulum.set_locale("invalid")
pendulum.datetime(2019, 5, 1, tz="Asia/Seoul")
dt = pendulum.local(2019, 5, 1)
print(dt.timezone.name)
now = pendulum.now()
print(now)
naive = pendulum.naive(2019, 5, 1)
print(naive.timezone)
dt = pendulum.parse('2019-05-01T22:00:00')
print(dt)
pendulum.set_locale('ko')
print(pendulum.now().add(years=1).diff_for_humans())
dt = pendulum.parse('2019-05-01T22:00:00')
print(dt.year)
print(dt.month)
print(dt.day)
print(dt.hour)
print(dt.minute)
print(dt.second)
print(dt.microsecond)
print(dt.day_of_week)
print(dt.day_of_year)
print(dt.week_of_month)
print(dt.week_of_year)
def 时间_设置语言包(名称="zh"):
pendulum.set_locale(名称)
import datetime
import pendulum
from src.config import config
pendulum.set_locale(name=config["discord"]["interface"]["time_local"])
def duration_readable(seconds: int) -> str:
"""
Функция для читаемого формата оставшегося времени
:param seconds: Количество секунд
:return: Строка с читаемым форматом времени
"""
return pendulum.duration(seconds=seconds).in_words()
def timedelta_readable(time: datetime.datetime) -> str:
"""
Функция для читаемого формата разницы времени
:param time: Время
:return:
"""
delta_seconds: float = (datetime.datetime.now() - time).total_seconds()
return pendulum.now().subtract(
seconds=int(delta_seconds)).diff_for_humans()
from selenium.webdriver import Chrome
from selenium.webdriver.support.ui import WebDriverWait, Select
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import NoSuchElementException
from webdriver_manager.chrome import ChromeDriverManager
from atexit import register
from lxml.html import fromstring
from collections import defaultdict
from json import dump
import pendulum
pendulum.set_locale('de')
now = pendulum.now()
month = now.month
year = now.year
if month == 1:
SEM = f"{year-1}W"
elif month in {2, 3, 4, 5, 6, 7}:
SEM = f"{year}S"
else:
SEM = f"{year}W"
semesters = [SEM, f"{int(SEM[:4])-1}{SEM[-1]}"]
def collapse_whitespace(s):
return ' '.join(s.split())
from datetime import datetime
import pendulum
import redis
from squashbot.utils import previous_days, grouper, markdown_link, custom_xrange as time_range
from kortovnet import KortovNet
from telepot.exception import TelegramError
import gettext
import os
MSK = 'Europe/Moscow'
LOCALE = 'ru_RU'
CHAT_MEMBERS = ['left_chat_member', 'new_chat_member']
TOP_LOCS = 3
TOP_PLAYERS = 3
pendulum.set_locale('ru')
localedir = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'locale')
translate = gettext.translation('squashbot', localedir, fallback=True)
_ = translate.gettext
GameInputStage = enum.Enum(value='GameInputStage',
names=[
'start', 'date', 'time', 'location',
'first_player', 'second_player', 'result',
'confirmation'
])
class GameInputHandler(telepot.aio.helper.ChatHandler):
"""Class for handling chat input."""
def __init__(self, *args, **kwargs):
import os
import logging
from functools import lru_cache
from typing import Optional, List, Dict, Any, Text
import pendulum
from wechatpy.work.client import WeChatClient
from wechatpy.work.client.api import WeChatDepartment, WeChatUser, WeChatCalendar, WeChatSchedule
pendulum.set_locale('zh')
WECOM_CORP_ID = os.environ.get('WECOM_CORP_ID')
WECOM_CORP_SECRET = os.environ.get('WECOM_CORP_SECRET')
access_token = None
calendar_id = os.environ.get('WECOM_CALENDAR_ID')
calendar_user_id = os.environ.get('WECOM_CALENDAR_USER_ID')
logger = logging.getLogger(__name__)
client = WeChatClient(WECOM_CORP_ID,
WECOM_CORP_SECRET,
access_token=access_token)
@lru_cache(maxsize=10)
def get_all_calendar_schedules() -> List[Dict[Text, Any]]:
result = []
offset = 0
import pendulum
pendulum.set_locale('ja')
import requests
from bs4 import BeautifulSoup
import wikipedia
class Scraper:
"""
Parse HTML file given URL.
Parameters
----------
response: class:`requests.models.Response` object.
soup: class:`bs4.BeautifulSoup` object.
"""
def __init__(self, response=None, soup=None):
self.response = None
self.soup = None
def get(self, url):
"""Create BeautifulSoup object from a responded HTML
Parameters
----------
url: str
URL of a page that is to be parsed.
Returns
-------
None
def test_set_locale_malformed_locale(locale):
pendulum.set_locale(locale)
pendulum.set_locale("en")
def tearDown(self):
pendulum.set_locale('en')
def setUp(self):
pendulum.set_locale(self.locale)
def setup():
pendulum.set_locale('zh')
callback.CALLBACKS_ON_SCRIPT_LOAD.append(reset_warning_history)
callback.CALLBACKS_ON_SCRIPT_LOAD.append(warn_missing_frames)
callback.CALLBACKS_ON_SCRIPT_LOAD.append(warn_mtime)
callback.CALLBACKS_ON_SCRIPT_SAVE.append(warn_missing_frames)
from django.shortcuts import render
from .models import Calendario, Docente
# Usando no examplo
from django.http import HttpResponseRedirect
from .forms import PeriodoForm, NameForm
# Usado nos testes
from django.http import HttpResponse
import pendulum
pendulum.set_locale('pt-br')
from tempfile import NamedTemporaryFile
from openpyxl import Workbook
from openpyxl import load_workbook, Workbook
import openpyxl
from openpyxl.styles import PatternFill, Border, Side, Alignment, Protection, Font, Fill
from openpyxl.cell import Cell
from openpyxl.drawing.image import Image
import datetime
import pendulum
pendulum.set_locale('pt-br')
from django.conf.urls.static import static
from django.templatetags.static import static
from annoying.functions import get_object_or_None
# Para garantir acesso a imagens em produção/heroku
from django.contrib.staticfiles import finders
def come(request):
def dsc(dia, mes, ano):
date = pendulum.date(ano, mes, dia)
def main():
import sys
import logging
import logging.config
logger = logging.getLogger()
MIN_PYTHON = (3, 6)
if sys.version_info < MIN_PYTHON:
sys.exit("Python %s.%s or later is required.\n" % MIN_PYTHON)
import os
IS_VENV = os.getenv('VIRTUAL_ENV') is not None
import etm.__version__ as version
etm_version = version.version
etmdir = os.getcwd()
loglevel = 2 # info
log_levels = [str(x) for x in range(1, 6)]
if len(sys.argv) > 1 and sys.argv[1] in log_levels:
loglevel = sys.argv.pop(1)
if len(sys.argv) > 1 and os.path.isdir(sys.argv[1]):
etmdir = sys.argv.pop(1)
logdir = os.path.normpath(os.path.join(etmdir, 'logs'))
if not os.path.isdir(logdir):
os.makedirs(logdir)
backdir = os.path.normpath(os.path.join(etmdir, 'backups'))
if not os.path.isdir(backdir):
os.makedirs(backdir)
import etm.options as options
settings = options.Settings(etmdir).settings
setup_logging = options.setup_logging
setup_logging(loglevel, logdir)
# in model, view, ...,
# logger = logging.getLogger()
# will acquire this logger!
logger.info(f"running in a virtual environment: {IS_VENV}")
secret = settings.get('secret')
import pendulum
locale = settings.get('locale', None)
if locale:
pendulum.set_locale(locale)
today = pendulum.today()
day = today.end_of('week') # Sunday
WA = {i: day.add(days=i).format('ddd')[:2] for i in range(1, 8)}
import etm.ical as ical
import etm.data as data
data.secret = secret
from etm.data import Mask
dbfile = os.path.normpath(os.path.join(etmdir, 'db.json'))
cfgfile = os.path.normpath(os.path.join(etmdir, 'cfg.yaml'))
ETMDB = data.initialize_tinydb(dbfile)
DBITEM = ETMDB.table('items', cache_size=None)
DBARCH = ETMDB.table('archive', cache_size=None)
from etm.model import about
from etm.model import import_file
import etm.model as model
model.etm_version = etm_version
model.secret = secret
model.data = data
model.ical = ical
model.Mask = Mask
model.WA = WA
model.ETMDB = ETMDB
model.DBITEM = DBITEM
model.DBARCH = DBARCH
model.settings = settings
# we put settings into the model namespace so model.Dataview will have it
dataview = model.DataView(etmdir)
datetime_calculator = model.datetime_calculator
Item = model.Item
item = model.Item(dbfile)
format_time = model.format_time
format_datetime = model.format_datetime
format_duration = model.format_duration
# since dataview calls schedule it will also have settings
completions = dataview.completions
expansions = settings["expansions"]
if expansions:
for x in expansions:
completions.append(f"@x {x}")
style = dataview.settings["style"]
parse_datetime = model.parse_datetime
logger.info(f"initialized TinyDB using {dbfile}")
import etm.view as view
view.cfgfile = cfgfile
view.model = model
view.item = item
view.import_file = import_file
view.etmdir = etmdir
view.datetime_calculator = datetime_calculator
view.about = about
view.wrap = model.wrap
view.settings = settings
view.format_time = format_time
view.format_datetime = format_datetime
view.format_duration = format_duration
view.parse_datetime = parse_datetime
view.ETMDB = ETMDB
view.DBITEM = DBITEM
view.DBARCH = DBARCH
view.dataview = dataview
view.completions = completions
view.expansions = expansions
view.terminal_style = style
logger.info(f"setting terminal_style: {style}")
if len(sys.argv) > 1:
if sys.argv[1] == 'model':
logger.info(f"calling model doctest with etmdir: {etmdir}, argv: {sys.argv}")
import doctest
doctest.testmod(model)
elif sys.argv[1] == 'view':
logger.info(f"calling view doctest with etmdir: {etmdir}, argv: {sys.argv}")
import doctest
doctest.testmod(view)
elif sys.argv[1] == 'data':
logger.info(f"calling data doctest with etmdir: {etmdir}, argv: {sys.argv}")
import doctest
doctest.testmod(data)
else:
logger.info(f"calling data.main with etmdir: {etmdir}, argv: {sys.argv}")
model.main(etmdir, sys.argv)
else:
logger.info(f"calling view.main with etmdir: {etmdir}")
from etm.view import main
main(etmdir)
import pandas as pd
import pendulum
from settings import SOURCE_FILES, SEP, ENCODING, TRANSFORMED_FILES
pendulum.set_locale('fr')
def calcul_age(date):
date = date.split(' ')[0]
maxDate = pendulum.datetime(1998, 1, 1)
date_pendulum = pendulum.parse(date)
return maxDate.diff(date_pendulum).in_years()
def tranche_age(age):
if age < 35:
return 'Moins de 35 ans'
elif 35 <= age <= 50:
return '35 - 50 ans'
else:
return 'Plus de 50 ans'
def main():
df_employes = pd.read_csv(SOURCE_FILES['employes'],
sep=SEP,
encoding=ENCODING)
dim_employes = df_employes.drop(
['HomePhone', 'Extension', 'Photo', 'Notes', 'ReportsTo', 'PhotoPath'],
axis=1)
from pendulum import set_locale, now
set_locale('pt-br')
n = now('UTC')
print(n.add(years=2).diff_for_humans())
