def abort_task(dburi, taskid):
""" immediately abort the given task
This will be done by doing a preemptive kill on
its associated worker.
"""
engine = create_engine(find_dburi(dburi))
task = Task.byid(engine, taskid)
task.abort()
@rework.command('vacuum')
@click.argument('dburi')
@click.option('--workers', is_flag=True, default=False)
@click.option('--tasks', is_flag=True, default=False)
@click.option('--finished', type=click.DateTime())
def vacuum(dburi, workers=False, tasks=False, finished=None):
" delete non-runing workers or finished tasks "
if not (workers or tasks):
print('to cleanup old workers or tasks '
'please use --workers or --tasks')
return
if workers and tasks:
print('vacuum deletes workers or tasks, not both ' 'at the same time')
return
engine = create_engine(find_dburi(dburi))
if finished is None:
finished = utcnow()
if workers:
count = cleanup_workers(engine, finished)
print(detail.format(location, "None", **field_widths))
else:
for start, end in date_ranges:
print(
detail.format(
location, f'{start} to {end}'
if start and end else str(start), **field_widths))
location = ""
_log.debug(f'{overall}.')
@cli.command("rh")
@click.option('-s',
'--start',
'start',
type=click.DateTime(formats=["%Y-%m-%d"]),
metavar='START',
help="The history start date (ISO format).")
@click.option('-e',
'--end',
'end',
nargs=1,
type=click.DateTime(formats=["%Y-%m-%d"]),
metavar='END',
help="The history end date (ISO format).")
@click.argument('location_name', nargs=1, metavar='LOCATION')
@click.pass_obj
def report_history(database: db.Database, location_name: str, start: datetime,
end: datetime):
"""Get history from a locations weather data. LOCATION can be either the location name or alias name."""
overall = StopWatch("rh overall time", in_ms=True)
f"gdal_calc.py --quiet -A {f} -B {mask_fname} --outfile=tmp_out.tif "
f' --calc="A * B " --NoDataValue=0')
_log_and_run(cmd)
_log_and_run(f"mv tmp_out.tif {f}")
_log_and_run(
f"rm {mask_fname} {mask_fname.replace('.bin', '.hdr')}")
@cli.command("subset")
@click.option("--bbox",
nargs=4,
type=float,
help="Window lat/lon bounds: left bot right top")
@click.option("--out-dir", "-o", type=click.Path(exists=True))
@click.option("--in-dir", "-i", type=click.Path(exists=True))
@click.option("--start-date", "-s", type=click.DateTime(formats=["%Y-%m-%d"]))
@click.option("--end-date", "-e", type=click.DateTime(formats=["%Y-%m-%d"]))
def subset(bbox, out_dir, in_dir, start_date, end_date):
"""Read window subset from .geos in another directory
Writes the smaller .geos to `outpath`, along with the
extra files going with it (elevation.dem, .orbtimings)
"""
import apertools.sario
from apertools.utils import force_symlink
import apertools.subset
if abspath(out_dir) == abspath(in_dir):
raise ValueError("--in-dir cannot be same as --out-dir")
# dems:
from kraken_ore_generator.top_of_book import tob_generation
@click.group()
def cli():
pass
@cli.command("ore")
@click.option("--query_url",
"-q",
type=click.STRING,
help="CDM Metadata Query Service URL")
@click.option("--date",
"-d",
type=click.DateTime(["%Y-%m-%d"]),
help="Date to process")
@click.option("--pair",
"-p",
type=click.STRING,
help="Name of currency pair to process")
@click.option("--ore_path",
"-op",
type=click.STRING,
help="Path to write ORE file")
@click.option("--state_path",
"-sp",
type=click.STRING,
help="Path to write next state file")
@click.option("--extractor-license-path",
"-ep",
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
import click
from ack.readers.google_search_console.reader import GoogleSearchConsoleReader
from ack.utils.args import extract_args
from ack.utils.date_handler import DEFAULT_DATE_RANGE_FUNCTIONS
from ack.utils.processor import processor
@click.command(name="read_search_console")
@click.option("--search-console-client-id", required=True)
@click.option("--search-console-client-secret", required=True)
@click.option("--search-console-access-token", default="")
@click.option("--search-console-refresh-token", required=True)
@click.option("--search-console-dimensions", required=True, multiple=True)
@click.option("--search-console-site-url", required=True)
@click.option("--search-console-start-date", type=click.DateTime(), default=None)
@click.option("--search-console-end-date", type=click.DateTime(), default=None)
@click.option("--search-console-date-column", type=click.BOOL, default=False)
@click.option("--search-console-row-limit", type=click.INT, default=25000)
@click.option(
"--search-console-date-range",
type=click.Choice(DEFAULT_DATE_RANGE_FUNCTIONS.keys()),
help=f"One of the available ACK default date ranges: {DEFAULT_DATE_RANGE_FUNCTIONS.keys()}",
)
@processor()
def google_search_console(**params):
return GoogleSearchConsoleReader(**extract_args("search_console_", params))
def get_click_type(*, annotation: Any,
parameter_info: ParameterInfo) -> click.ParamType:
if annotation == str:
return click.STRING
elif annotation == int:
if parameter_info.min is not None or parameter_info.max is not None:
min_ = None
max_ = None
if parameter_info.min is not None:
min_ = int(parameter_info.min)
if parameter_info.max is not None:
max_ = int(parameter_info.max)
return click.IntRange(min=min_,
max=max_,
clamp=parameter_info.clamp)
else:
return click.INT
elif annotation == float:
if parameter_info.min is not None or parameter_info.max is not None:
return click.FloatRange(
min=parameter_info.min,
max=parameter_info.max,
clamp=parameter_info.clamp,
)
else:
return click.FLOAT
elif annotation == bool:
return click.BOOL
elif annotation == UUID:
return click.UUID
elif annotation == datetime:
return click.DateTime(formats=parameter_info.formats)
elif (annotation == Path or parameter_info.allow_dash
or parameter_info.path_type or parameter_info.resolve_path):
return click.Path( # type: ignore
exists=parameter_info.exists,
file_okay=parameter_info.file_okay,
dir_okay=parameter_info.dir_okay,
writable=parameter_info.writable,
readable=parameter_info.readable,
resolve_path=parameter_info.resolve_path,
allow_dash=parameter_info.allow_dash,
path_type=parameter_info.path_type,
)
elif lenient_issubclass(annotation, TextFile):
return click.File(
mode=parameter_info.mode or "r",
encoding=parameter_info.encoding,
errors=parameter_info.errors,
lazy=parameter_info.lazy,
atomic=parameter_info.atomic,
)
elif lenient_issubclass(annotation, BinaryFileRead):
return click.File(
mode=parameter_info.mode or "rb",
encoding=parameter_info.encoding,
errors=parameter_info.errors,
lazy=parameter_info.lazy,
atomic=parameter_info.atomic,
)
elif lenient_issubclass(annotation, BinaryFileWrite):
return click.File(
mode=parameter_info.mode or "wb",
encoding=parameter_info.encoding,
errors=parameter_info.errors,
lazy=parameter_info.lazy,
atomic=parameter_info.atomic,
)
elif lenient_issubclass(annotation, Enum):
return click.Choice(
[item.value for item in annotation],
case_sensitive=parameter_info.case_sensitive,
)
raise RuntimeError(f"Type not yet supported: {annotation}")
if res.status_code == 200:
click.echo('User is now logged out')
else:
click.echo(res.text)
else:
click.echo('No user is logged in')
@main.command(name='ActualTotalLoad', help='Actual total energy load consumed in an area')
@click.option('--area', '-a', required=True, type=str, help='Area of interest')
@click.option('--timeres', '-t', required=True, type=str,
help='Timeres for the data, can be one of PT15M, PT30M or PT60M')
@optgroup.group('Date', cls=RequiredMutuallyExclusiveOptionGroup,
help='Date of interest, can be either a date of the form YYYY-MM-DD, month of form YYYY-MM or year of form YYYY')
@optgroup.option('--date', '-d', type=click.DateTime(formats=['%Y-%m-%d']))
@optgroup.option('--month', '-m', type=click.DateTime(formats=["%Y-%m"]))
@optgroup.option('--year', '-y', type=click.DateTime(formats=["%Y"]))
@click.option('--format', '-f', default='json',
help='Format in which the data appears, can be either json (default) or csv')
def ActualTotalLoad(area, timeres, date, month, year, format):
if date != None:
mydate = date.strftime("%Y-%m-%d")
datetype = 'date'
elif month != None:
mydate = month.strftime("%Y-%m")
datetype = 'month'
elif year != None:
mydate = year.strftime("%Y")
datetype = 'year'
else:
def __init__(self, separator: str = ',', formats: List[str] = None):
super().__init__(click.DateTime(formats=formats),
separator=separator,
name='datetimes')
PYTHON_MIN_VERSION = (3, 6)
APP_NAME = 'poc' # Created in the template
@click.command()
@click.option(
'-c',
'--config',
required=True,
type=str,
help='Location of Configuration.\ngs://[bucket]/[config]\n/full/local/path)'
)
@click.option('-sd',
'--start_date',
required=False,
type=click.DateTime(formats=['%Y%m%d']))
@click.option('-ed',
'--end_date',
required=False,
type=click.DateTime(formats=['%Y%m%d']))
@click.option('-b', '--backfill', required=False, is_flag=True)
def instantiate_etl_runner(config, start_date, end_date, backfill):
runner = ETLRunner(APP_NAME, config, ETLPipeline)
runner.run(start_date, end_date, backfill)
if __name__ == "__main__":
assert tuple(
sys.version_info
) >= PYTHON_MIN_VERSION, "Please update to Python {}.{}".format(
def log(core, **kwargs):
interactive = kwargs.pop('interactive', False)
params = {k: v for k, v in kwargs.items() if v}
if 'today' in params and 'date' in params:
raise click.BadParameter('Must specify exactyl one of date and today')
if 'today' in params:
params['session_date'] = date.today()
del params['today']
if 'exercise' not in params:
interactive = True
params['exercise'] = click.prompt(
'enter an exercise (existing options: {})'.format(
', '.join(core.all_exercises())), str)
if interactive or ('session_date' not in params
or not params['session_date']):
if (click.prompt(
"Did you do the workout today?",
default=False, type=bool
)):
params['session_date'] = date.today()
else:
params['session_date'] = click.prompt(
"When did you do the workout?",
type=click.DateTime()
)
if interactive and 'sets' not in params:
reps = click.prompt("sets?", type=int, default=0)
if reps:
params['reps'] = reps
if interactive and 'reps' not in params:
c = click.prompt("reps per set?", type=int, default=0)
if c:
params['reps'] = c
if interactive and 'duration' not in params:
c = click.prompt("duration?", type=str, default=0)
if c:
params['duration'] = validator(core, "duration", c)
if interactive and 'failure' not in params:
c = click.prompt("failure", type=bool, default=False)
if c:
params['failure'] = c
if params.get('duration', None):
dt = params['duration']
params['duration'] = timedelta(
hours=dt.hour,
minutes=dt.minute,
seconds=dt.second)
session = Session(**params)
if click.confirm('save ' + str(session) + '?"'):
for result in core.insert(session):
click.echo(result)
else:
click.echo('aborted')
import logging
from google.cloud import bigquery
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
COUNTRIES = [
'Worldwide', 'United States', 'Germany', 'France', 'India', 'Brazil',
'China', 'Indonesia', 'Russia', 'Italy', 'Poland'
]
# migrated from https://github.com/mozilla/Fx_Usage_Report/tree/489ca258b14776c01f3021080b2dd686d239dea3/usage_report/annotations # noqa
STATIC_ANNOTATIONS = ["annotations_webusage.json", "annotations_hardware.json"]
date_type = click.DateTime()
@click.command()
@click.option(
"--date_to",
type=date_type,
required=True,
help="End date for producing version release dates",
)
@click.option('--output_bucket', required=True)
@click.option('--output_prefix', required=True)
def main(date_to, output_bucket, output_prefix):
"""Export annotations to S3"""
client = bigquery.Client()
from lift import util
from datetime import datetime, date, timedelta
formats = util.listing_query_date_formats
@click.group()
@click.pass_context
def cli(ctx, **kwargs):
ctx.obj = core.create()
@click.option('-t', '--time', 'duration',
type=click.DateTime(formats=util.duration_formats),
default=None)
@click.option('-p', '--rpe', 'effort',
type=click.IntRange(
min=util.rpe_range[0],
max=util.rpe_range[1]
),
default=None)
@click.option('-s', '--sets',
type=click.INT,
default=None)
@click.option('-r', '--reps', type=click.INT, default=None)
@click.option('-w', '--weight', type=click.FLOAT, default=None)
@click.option('-d', '--date', 'session_date',
type=click.DateTime())
@click.option('-e', '--exercise', type=str)
@click.command(context_settings=CONTEXT_SETTINGS)
@click.option('--format',
'-f',
prompt=True,
default='csv',
type=click.Choice(['json', 'csv', 'mongo', 'all', 'none']))
@click.option('--outdir',
'-o',
prompt=True,
type=click.Path(),
default=lambda: os.getcwd() + '/out')
@click.option('--date',
'-d',
prompt=True,
type=click.DateTime(formats=['%Y-%m-%d']),
default=lambda: str(datetime.datetime.now())[:10])
@click.argument('input_dirs', nargs=-1, type=click.Path(exists=True))
def cli(format, outdir, date, input_dirs):
"""
excel-shred Version 1.0.0
Open an Excel workbook, and convert all sheets to json datasets
:param date: the date of the input audit
:param outdir: output directory for files
:param format: the output format
:param input_dirs: one or more directory paths containing excel workbooks
Examples:
\b
@pass_script_info
def run_server(info):
app = info.load_app()
Limiter(
app,
key_func=get_ipaddr,
default_limits=config.config.rate_limit
)
if config.config.allow_cors:
CORS(app)
serve(app, host=config.config.host, port=config.config.port, url_prefix=config.config.base_url)
@cli.command("generate", help="generate new token")
@click.option("-o", "--one-time", is_flag=True, help="make token one-time-useable")
@click.option("-e", "--expires", type=click.DateTime(formats=["%Y-%m-%d"]), default=None, help='expire date: in ISO-8601 format (YYYY-MM-DD)')
def generate_token(one_time, expires):
token = tokens.tokens.new(ex_date=expires, one_time=one_time)
print(token.name)
@cli.command("status", help="view status or disable")
@click.option("-s", "--status", default=None, help="token status")
@click.option("-l", "--list", is_flag=True, help="list tokens")
@click.option("-d", "--disable", default=None, help="disable token")
def status_token(status, list, disable):
if disable:
if tokens.tokens.disable(disable):
print("Token disabled")
else:
print("Token couldn't be disabled")
from functools import partial
import click
import numpy as np
import os
from desafio_iafront.data.saving import save_partitioned
from desafio_iafront.jobs.clusters.clusters import dbscan
from desafio_iafront.data.dataframe_utils import read_partitioned_json
from desafio_iafront.jobs.common import filter_date
@click.command()
@click.option('--dataset', type=click.Path(exists=True))
@click.option('--saida',
type=click.Path(exists=False, dir_okay=True, file_okay=False))
@click.option('--data-inicial', type=click.DateTime(formats=["%d/%m/%Y"]))
@click.option('--data-final', type=click.DateTime(formats=["%d/%m/%Y"]))
@click.option('--eps', type=click.FLOAT)
@click.option('--samples', type=click.INT)
def main(dataset: str, eps: float, samples: int, saida: str, data_inicial,
data_final):
filter_function = partial(filter_date,
data_inicial=data_inicial,
data_final=data_final)
dataset = read_partitioned_json(file_path=dataset,
filter_function=filter_function)
vector = np.asarray(list(dataset['features'].to_numpy()))
labels = dbscan(vector, eps, samples)
flatlib.const.MERCURY: "☿",
flatlib.const.VENUS: "♀",
flatlib.const.MARS: "♂",
flatlib.const.JUPITER: "♃",
flatlib.const.SATURN: "♄",
}
def convert_into_stupid_flatlib_format(dt):
return Datetime(dt.strftime("%Y/%m/%d"), dt.strftime("%H:%M"))
@click.command()
@click.option("--latitude", type=click.FLOAT, required=True)
@click.option("--longitude", type=click.FLOAT, required=True)
@click.option("--date", type=click.DateTime(), default=datetime.now())
def main(latitude: float, longitude: float, date: datetime):
flatlib_datetime = convert_into_stupid_flatlib_format(date)
position = GeoPos(latitude, longitude)
chart = Chart(flatlib_datetime, position)
for planet in planet_symbols.keys():
planet_position = chart.getObject(planet)
print(
planet_symbols[planet],
sign_symbols[planet_position.sign],
"℞"
if planet_position.movement() == flatlib.const.RETROGRADE else "",
end="",
)
print()
help="Number of failed updates before a video is not checked for updates any more.")
@click.option("--max-backlog", "-b", type=click.INT,
help="Number of videos in a playlist that are checked for updates.")
@pass_ytcc
def update(ytcc: core.Ytcc, max_fail: Optional[int], max_backlog: Optional[int]):
"""Check if new videos are available.
Downloads metadata of new videos (if any) without playing or downloading the videos.
"""
ytcc.update(max_fail, max_backlog)
common_list_options = [
click.Option(["--tags", "-c"], type=CommaList(str),
help="Listed videos must be tagged with one of the given tags."),
click.Option(["--since", "-s"], type=click.DateTime(["%Y-%m-%d"]),
default="1970-01-03", # Minimum supported by .timestamp() on Windows
help="Listed videos must be published after the given date."),
click.Option(["--till", "-t"], type=click.DateTime(["%Y-%m-%d"]),
default="3001-1-19", # Maximum supported by .timestamp() on Windows (Y3K Bug)
help="Listed videos must be published before the given date."),
click.Option(["--playlists", "-p"], type=CommaList(str),
help="Listed videos must be in on of the given playlists."),
click.Option(["--ids", "-i"], type=CommaList(int),
help="Listed videos must have the given IDs."),
click.Option(["--watched", "-w"], is_flag=True, default=False,
help="Only watched videos are listed."),
click.Option(["--unwatched", "-u"], is_flag=True, default=False,
help="Only unwatched videos are listed."),
click.Option(["--order-by", "-o"], type=(click.Choice(VideoAttr), click.Choice(Direction)),
multiple=True, help="Set the column and direction to sort listed videos.")
type=click.Choice(REPORT_TYPES),
default=REPORT_TYPES[0])
@click.option(
"--sa360-column",
"sa360_columns",
multiple=True,
help="https://developers.google.com/search-ads/v2/report-types",
)
@click.option(
"--sa360-saved-column",
"sa360_saved_columns",
multiple=True,
help=
"https://developers.google.com/search-ads/v2/how-tos/reporting/saved-columns",
)
@click.option("--sa360-start-date",
type=click.DateTime(),
help="Start date of the report")
@click.option("--sa360-end-date",
type=click.DateTime(),
help="End date of the report")
@click.option(
"--sa360-date-range",
type=click.Choice(DEFAULT_DATE_RANGE_FUNCTIONS.keys()),
help=
f"One of the available ACK default date ranges: {DEFAULT_DATE_RANGE_FUNCTIONS.keys()}",
)
@processor("sa360_access_token", "sa360_refresh_token", "sa360_client_secret")
def google_sa360(**kwargs):
return GoogleSA360Reader(**extract_args("sa360_", kwargs))
def grant(general_config,
bob,
bob_encrypting_key,
bob_verifying_key,
label,
value,
rate,
expiration,
m, n,
character_options,
config_file,
force):
"""Create and enact an access policy for some Bob. """
# Setup
emitter = setup_emitter(general_config)
ALICE = character_options.create_character(emitter, config_file, general_config.json_ipc)
# Policy option validation
if ALICE.federated_only:
if any((value, rate)):
message = "Can't use --value or --rate with a federated Alice."
raise click.BadOptionUsage(option_name="--value, --rate", message=message)
elif bool(value) and bool(rate):
raise click.BadOptionUsage(option_name="--rate", message="Can't use --value if using --rate")
# Grantee selection
if bob and any((bob_encrypting_key, bob_verifying_key)):
message = '--bob cannot be used with --bob-encrypting-key or --bob-veryfying key'
raise click.BadOptionUsage(option_name='--bob', message=message)
if bob:
card = Card.load(identifier=bob)
if card.character is not Bob:
emitter.error('Grantee card is not a Bob.')
raise click.Abort
paint_single_card(emitter=emitter, card=card)
if not force:
click.confirm('Is this the correct grantee (Bob)?', abort=True)
bob_encrypting_key = card.encrypting_key.hex()
bob_verifying_key = card.verifying_key.hex()
# Interactive collection follows:
# TODO: Extricate to support modules
# - Disclaimer
# - Label
# - Expiration Date & Time
# - M of N
# - Policy Value (ETH)
# Policy Expiration
# TODO: Remove this line when the time is right.
paint_probationary_period_disclaimer(emitter)
# Label
if not label:
label = click.prompt(f'Enter label to grant Bob {bob_verifying_key[:8]}', type=click.STRING)
if not force and not expiration:
if ALICE.duration_periods:
# TODO: use a default in days or periods?
expiration = maya.now() + timedelta(days=ALICE.duration_periods) # default
if not click.confirm(f'Use default policy duration (expires {expiration})?'):
expiration = click.prompt('Enter policy expiration datetime', type=click.DateTime())
else:
# No policy duration default default available; Go interactive
expiration = click.prompt('Enter policy expiration datetime', type=click.DateTime())
# TODO: Remove this line when the time is right.
enforce_probationary_period(emitter=emitter, expiration=expiration)
# Policy Threshold and Shares
if not n:
n = ALICE.n
if not force and not click.confirm(f'Use default value for N ({n})?', default=True):
n = click.prompt('Enter total number of shares (N)', type=click.INT)
if not m:
m = ALICE.m
if not force and not click.confirm(f'Use default value for M ({m})?', default=True):
m = click.prompt('Enter threshold (M)', type=click.IntRange(1, n))
# Policy Value
policy_value_provided = bool(value) or bool(rate)
if not ALICE.federated_only and not policy_value_provided:
rate = ALICE.default_rate # TODO #1709 - Fine tuning and selection of default rates
if not force:
default_gwei = Web3.fromWei(rate, 'gwei')
prompt = "Confirm rate of {node_rate} gwei ({total_rate} gwei per period)?"
if not click.confirm(prompt.format(node_rate=default_gwei, total_rate=default_gwei*n), default=True):
interactive_rate = click.prompt('Enter rate per period in gwei', type=GWEI)
# TODO: Validate interactively collected rate (#1709)
click.confirm(prompt.format(node_rate=rate, total_rate=rate*n), default=True, abort=True)
rate = Web3.toWei(interactive_rate, 'gwei')
# Request
grant_request = {
'bob_encrypting_key': bob_encrypting_key,
'bob_verifying_key': bob_verifying_key,
'label': label,
'm': m,
'n': n,
'expiration': expiration,
}
if not ALICE.federated_only:
if value:
grant_request['value'] = value
elif rate:
grant_request['rate'] = rate # in wei
if not force and not general_config.json_ipc:
confirm_staged_grant(emitter=emitter, grant_request=grant_request)
emitter.echo(f'Granting Access to {bob_verifying_key[:8]}', color='yellow')
return ALICE.controller.grant(request=grant_request)
for page in scraper.find_all_pages(base_link_template.format(single_date=single_date)):
writer.writerow([link_template.format(page=page, single_date=single_date)])
# find_all_pages(None, None)
# download_pages(None, None)
# scrape_pages(None, None)
@click.group()
def cli():
pass
@click.command()
@click.option('--file', default="/tmp/pages.csv", help='Destination file for pages to be written')
@click.option('--date-start', type = click.DateTime(formats=["%Y-%m-%d"]), default=str(date.today()), help='number of greetings')
@click.option('--date-end', type = click.DateTime(formats=["%Y-%m-%d"]), default=str(date.today()), help='number of greetings')
def find_all_pages(file, date_start, date_end):
date_start = date_start.date()
date_end = date_end.date()
click.echo(f"Writing pages from {date_start} to {date_end} into {file}")
with open(file, "a") as pages_file:
writer = csv.writer(pages_file, delimiter=",")
for single_date in daterange(date_start, date_end):
base_link_template = "https://www.transfermarkt.co.uk/transfers/transfertagedetail/statistik/top/plus/0?land_id_ab=&land_id_zu=&leihe=true&datum={single_date}"
link_template = "https://www.transfermarkt.co.uk/transfers/transfertagedetail/statistik/top/plus/1/page/{page}?land_id_ab=&land_id_zu=&leihe=true&datum={single_date}"
for page in scraper.find_all_pages(base_link_template.format(single_date=single_date)):
writer.writerow([link_template.format(page=page, single_date=single_date)])
@click.command()
for i in range(delta.days + 1):
dates_range.append(first_date + timedelta(days=i))
return dates_range
@click.group()
@click.pass_context
def cli(ctx):
pass
@cli.command()
@click.option(
'--start-date',
default=get_default_start_date,
type=click.DateTime(formats=['%d/%m/%Y']),
)
@click.option(
'--end-date',
default=get_default_end_date,
type=click.DateTime(formats=['%d/%m/%Y']),
)
@click.option(
'--refetch-start-date',
default=None,
type=click.DateTime(formats=['%d/%m/%Y']),
)
@click.option(
'--refetch-end-date',
default=None,
type=click.DateTime(formats=['%d/%m/%Y']),
from datetime import date
import click
@click.group()
def cli():
"Utility for http://b3.com.br datasets"
@cli.command()
@click.option("--date", type=click.DateTime(formats=["%Y-%m-%d"]))
@click.option("--chunk-size", type=int, default=10000)
def download(date, chunk_size):
"""Downloads quotes data"""
print(date)
if not date:
import subprocess
date = subprocess.getoutput("""echo $(curl --silent 'https://arquivos.b3.com.br/apinegocios/dates') | sed -e 's/"//g' -e 's/\[//g' -e 's/\]//g' | cut -d"," -f 1""")
else:
date = str(date)
from b3_data import download
download.download_tickercsv(date, chunk_size)
search_line = {"day": day, "suffix": suffix}
r = mongo_client.bookmarks.coords.find_one(search_line)
if r is None:
with open(path.join(coords_dir, "default_coords.json")) as f:
coords = json.load(f)
r = {"coords": coords}
mongo_client.bookmarks.coords.insert_one({**search_line, **r})
return r["coords"]
def _ss(s):
return s.split(" ")
@click.group()
@click.option("-d", "--day", type=click.DateTime(["%Y-%m-%d"]), default=datetime.now()+timedelta(days=2))
@click.option("--cache-folder", type=click.Path(), default=path.join(path.split(__file__)[0], ".cache"))
@click.option("--cpdf-executable", default="cpdf")
@click.option("--pdfs-folder", type=click.Path(), default=path.join(path.split(__file__)[0], "pdfs"))
@click.option("--pdf-template", type=click.Path(), default=path.join(path.split(__file__)[0], "pdfs", "test.pdf"))
@click.option("--suffix", default="")
@click.option("--mongo-url", envvar="MONGO_URL")
@click.pass_context
def bookmark(ctx, mongo_url, **kwargs):
basic_config_kwargs = {"handlers": [logging.StreamHandler(), ], }
if True:
basic_config_kwargs["level"] = logging.INFO
if True:
now = datetime.now()
log_file = f".logs/{kwargs['day'].strftime('%Y%m%d')}_{now.isoformat()}.log.txt"
_handler = logging.FileHandler(log_file)
def prepare_original_cli(source, destination):
"""Parse a file with a of participants, clean it up and save to json"""
with open(source) as fp:
lines = (line for line in fp)
valid_lines = filter_usernames(lines)
prepared_usernames = [prepare_username(uname) for uname in valid_lines]
with open(destination, "w") as ofp:
dump(prepared_usernames, ofp)
@cli.command("choose")
@click.argument(
"participants", type=click.Path(exists=True, file_okay=True, dir_okay=False)
)
@click.argument("date", type=click.DateTime(formats=["%d-%m-%Y"]), required=False)
@click.option("--n", default=1, show_default=True)
def choose_winner_cli(participants, date, n):
"""Choose a winner from PARTICIPANTS while using DATE to count seed"""
if date is None:
date = get_date_from_filename(participants)
with open(participants) as fp:
raw_usernames = load(fp)
hashed_participants = process_usernames(raw_usernames)
hashed_winners = choose_winners(hashed_participants, date, n=n)
participants = [prepare_username(uname) for uname in raw_usernames]
winners = find_winners(hashed_winners, participants)
click.echo(" ".join(winners))
@cli.command("prepare_hashed")
show_default=True,
help="Save footage to folder structure with format 'YYYY/MM/DD/camera_name/'",
)
@click.option(
"--download-request-timeout",
"download_timeout",
default=60.0,
show_default=True,
help="Time to wait before aborting download request, in seconds",
)
@click.option(
"--start",
type=click.DateTime(
formats=[
"%Y-%m-%d",
"%Y-%m-%dT%H:%M:%S",
"%Y-%m-%d %H:%M:%S",
"%Y-%m-%d %H:%M:%S%z",
]
),
required=False,
help=(
"Download range start time. "
# TODO(danielfernau): uncomment the next line as soon as the feature is implemented
# "If omitted, the time of the first available recording for each camera will be used."
),
)
@click.option(
"--end",
type=click.DateTime(
formats=[
"%Y-%m-%d",
plot = sns.barplot(
data=sorted_pd,
x=group_field,
y="count(DISTINCT CRAB_UserHN)",
color="tab:blue",
)
fig.savefig(
os.path.join(output_folder, f"{filename}.png"),
bbox_inches="tight",
)
@click.command()
@click.argument("start_date",
nargs=1,
type=click.DateTime(_VALID_DATE_FORMATS))
@click.argument("end_date", nargs=1, type=click.DateTime(_VALID_DATE_FORMATS))
@click.option(
"--by",
default="month",
type=click.Choice(_VALID_BY),
help="Either weekofyear or month",
)
@click.option(
"--generate_plots",
default=False,
is_flag=True,
help="Additional to the csv, generate the plot(s)",
)
@click.option("--output_folder",
default="./output",
type=click.STRING,
help='VAM code for dataset to process')
@click.option(
'--interleave',
is_flag=True,
help='Interleave MOD13 & MYD13 products to MXD (only works for VIM!)')
@click.option('--parallel-tiles',
type=click.INT,
default=1,
help='Number of tiles processed in parallel (default = 1)')
@click.option('--cleanup', is_flag=True, help='Remove collected HDF files')
@click.option('--force',
is_flag=True,
help='Force collect process not failing on corrupt inputs')
@click.option('--last-collected',
type=click.DateTime(formats=['%Y%j']),
help='Last collected date in julian format (YYYYDDD - %Y%j)')
@click.option("--tiles-required",
type=click.STRING,
help="Required tiles - supplied as csv list")
def cli(
src_dir: str,
targetdir: str,
compression: str,
vam_code: str,
interleave: bool,
parallel_tiles: int,
cleanup: bool,
force: bool,
last_collected: datetime,
tiles_required: str,
device_guid_argument = click.argument("device-guid", type=str)
change_device_name_option = click.option(
"--change-device-name",
required=False,
is_flag=True,
default=False,
help="""Prepend "deactivated_" and today's date to the name of any
deactivated devices.""",
)
DATE_FORMAT = "%Y-%m-%d"
purge_date_option = click.option(
"--purge-date",
required=False,
type=click.DateTime(formats=[DATE_FORMAT]),
default=None,
help="""The date on which the archive should be purged from cold storage in yyyy-MM-dd format.
If not provided, the date will be set according to the appropriate org settings.""",
)
@devices.command()
@device_guid_argument
@change_device_name_option
@purge_date_option
@sdk_options()
def deactivate(state, device_guid, change_device_name, purge_date):
"""Deactivate a device within Code42. Requires the device GUID to deactivate."""
_deactivate_device(state.sdk, device_guid, change_device_name, purge_date)
@click.argument("command")
@click.argument("parameters", default=None, required=False)
def raw_command(dev: SmartDevice, module, command, parameters):
"""Run a raw command on the device."""
import ast
if parameters is not None:
parameters = ast.literal_eval(parameters)
res = dev._query_helper(module, command, parameters)
click.echo(res)
@cli.command()
@pass_dev
@click.option("--year",
type=click.DateTime(["%Y"]),
default=None,
required=False)
@click.option("--month",
type=click.DateTime(["%Y-%m"]),
default=None,
required=False)
@click.option("--erase", is_flag=True)
def emeter(dev, year, month, erase):
"""Query emeter for historical consumption."""
click.echo(click.style("== Emeter ==", bold=True))
if not dev.has_emeter:
click.echo("Device has no emeter")
return
if erase:
@click.pass_context
@pass_project(migrate=True)
def schedule(project, ctx):
ctx.obj["project"] = project
ctx.obj["schedule_service"] = schedule_service = ScheduleService(project)
@schedule.command(short_help="[default] Add a new schedule")
@click.argument("name")
@click.argument("extractor")
@click.argument("loader")
@click.argument("interval")
@click.option("--transform",
type=click.Choice(["skip", "only", "run"]),
default="skip")
@click.option("--start-date", type=click.DateTime(), default=None)
@click.pass_context
def add(ctx, name, extractor, loader, transform, interval, start_date):
"""
Add a new schedule
\b
NAME:\tThe schedule name, must be unique
EXTRACTOR:\tWhich extractor should be used
LOADER:\tWhich loader should be used
INTERVAL:\tCron-like syntax to specify the schedule interval (@daily, @hourly, etc…)
"""
project = ctx.obj["project"]
schedule_service = ctx.obj["schedule_service"]
