def encode_channel(channel): hash_ids = Hashids( salt=current_app.config['HASH_IDS_SALT'], min_length=current_app.config['HASH_IDS_MIN_LENGTH'] ) return hash_ids.encode(channel)
def hash_id(self): """ :return: A reversible, unique, encoded value based on the bookmark's unique id. """ hashid = Hashids() return hashid.encode(self.id)
def proxy_user(id): hashidsLib = Hashids(salt='i&gz82r~W06,ELz0B?&:bS%R|BNJ?Hg}', min_length=10) hashid = hashidsLib.encode(id) r = requests.get(API + '/users/' + hashid) return json.dumps(r.json(), indent=4)
def test_single_number(self): h = Hashids() assert h.decode('j0gW') == (12345,) assert h.decode('jR') == (1,) assert h.decode('Lw') == (22,) assert h.decode('Z0E') == (333,) assert h.decode('w0rR') == (9999,)
def gen_hash(registered_account): """ Accepts a intsance of user account and returns a reversible 'time-unique' hash for it """ # get a timestamp (to make each generated hash unique): timestamp = int(time() * 1000) # encode the timestamp with secret_key: hashids = Hashids( salt=secret_key, min_length=UserHasher.timehash_min_length, alphabet=UserHasher.alphabet) timestamp_hash = hashids.encode(timestamp) # encode the user's pk with timestamp: hashids = Hashids( salt=str(timestamp), min_length=UserHasher.pkhash_min_length, alphabet=UserHasher.alphabet) pk_hash = hashids.encode(registered_account.pk) # return the combination delimited by UserHasher.delim: return "%s%s%s" % (timestamp_hash, UserHasher.delim, pk_hash)
def reverse_hash(hash_str): """ Accepts a unique hash string representing a user account and decodes it to return an actual intance of that account Returns None if decoded user does not exits """ # split the hash_str with the delim: hashs = hash_str.split(UserHasher.delim) # ensure the list has only 2 parts if len(hashs) != 2: return None # decode the timestamp_hash (i.e hashs[0] ) with the app secret key: hashids = Hashids( salt=secret_key, min_length=UserHasher.timehash_min_length, alphabet=UserHasher.alphabet) timestamp = hashids.decode(hashs[0])[0] # decode the pk_hash (i.e hashs[1] ) with the timestamp: hashids = Hashids( salt=str(timestamp), min_length=UserHasher.pkhash_min_length, alphabet=UserHasher.alphabet) account_pk = hashids.decode(hashs[1])[0] try: # return the account for that pk if it exists: registered_account = User.objects.get(pk=account_pk) return registered_account except ObjectDoesNotExist: # return None if it doesn't: return None
def post(self, request, *args, **kwargs): identifier = request.query_params.get("daemo_id", False) if not identifier: return Response("Missing identifier", status=status.HTTP_400_BAD_REQUEST) try: from django.conf import settings from hashids import Hashids hash = Hashids(salt=settings.SECRET_KEY) task_worker_id, task_id, template_item_id = hash.decode(identifier) with transaction.atomic(): task_worker = TaskWorker.objects.get(id=task_worker_id, task_id=task_id) task_worker_result, created = TaskWorkerResult.objects.get_or_create( task_worker_id=task_worker.id, template_item_id=template_item_id ) # only accept in progress, submitted, or returned tasks if task_worker.task_status in [1, 2, 5]: task_worker_result.status = 1 task_worker_result.result = request.data task_worker_result.save() return Response(request.data, status=status.HTTP_200_OK) else: return Response("Task cannot be modified now", status=status.HTTP_400_BAD_REQUEST) except ValueError: return Response("Invalid identifier", status=status.HTTP_400_BAD_REQUEST) except Exception: return Response("Fail", status=status.HTTP_400_BAD_REQUEST)
def url_key(self): """ This method will generate a hash id that can be used to create a shortened URL. """ hashid = Hashids() return hashid.encode(self.id)
def testhash(): stringtohash = Hashids(salt="This is a string") hashstring = stringtohash.encode(123) hashids = Hashids(salt="This is salt") hashid = hashids.encode(123) print(hashid) print(hashstring)
def post(self,siteid,id): if id is None: # create a new element form1 = self.get_form_obj() form1.populate() if form1.validate_on_submit(): wifisite = Wifisite.query.filter_by(id=siteid).first() #generate batch id batchid = str(uuid.uuid4()) cnt = 0 try: while cnt < int(form1.number.data): cnt = cnt + 1 newitem = self.get_modal_obj() newitem.populate_from_form(form1) #create voucher random = randint(100, 999) # randint is inclusive at both ends hashid = Hashids(salt=current_app.config['HASH_SALT'],min_length=10) newitem.voucher = hashid.encode(random,wifisite.id,wifisite.client_id) newitem.batchid = batchid newitem.site = wifisite db.session.add(newitem) db.session.commit() except : current_app.logger.exception('Exception while trying create vouchers') return jsonify({'status': 0,'msg':'Error while trying to create vouchers'}) else: return jsonify({'status': 1,'msg':'Added New Entry for:%s into Database'%self.entity_name}) else: return jsonify({'status':0,'msg': get_errors(form1)}) else: return jsonify({'status':0,'err': 'Voucher Editing is not allowed'})
def get_data(): users = [] accessed = [] User.objects.all().delete() Click.objects.all().delete() Stats.objects.all().delete() for x in range(100): new_user = User.objects.create_user(username=fake.user_name(), password='******', email = fake.email()) new_user.save() users.append(new_user) print(new_user) hashids = Hashids(min_length=6, salt="thisissalt") for x in range(500): new_click = Click(author=random.choice(users), title=fake.text(max_nb_chars=15), timestamp= fake.date_time_this_year(), orig = fake.url(), short = hashids.encode(x)) new_click.save() clicks.append(new_click) print(new_click) for x in range(5000): new_stat = Stats(click = random.choice(clicks), reader = random.choice(users), timestamp = fake.date_time_this_month()) new_stat.save() print(new_stat)
def createSession(): if not (request.get_json()["name"]): return "The name of the session is needed" name = request.get_json()["name"] string = get_random_string() hashids = Hashids(salt=name+string) hashid = hashids.encode(5,5,5) session = Sessions(name=name, sessionId=hashid) curr_session = mysql.session try: curr_session.add(session) curr_session.commit() except (ValueError, KeyError, TypeError) as error: application.logger.error('Error in create session - %s', error) curr_session.rollback() curr_session.flush() # for resetting non-commited .add() sessionId = session.id data = Sessions.query.filter_by(id=sessionId).first() config.read('muchvote_db.conf') result = [data.id, data.name, data.sessionId] return jsonify(session=result)
def generate_uid(): """Generate a unique id using a custom salt, alphabet and min length.""" salt = settings.SECRET_KEY alphabet = settings.UID_ALPHABET hashids = Hashids(salt=salt, alphabet=alphabet) unique_id = hashids.encode(int(time() * 1000)) return unique_id
def new(event, bucket): body = json.loads(event.get('body')) schema = load_files() try: validate(body, schema) except (jsonschema.exceptions.SchemaError, jsonschema.exceptions.ValidationError) as err: return respond(err=err) hashids = Hashids(salt='grabfromenv') # TODO: get the salt from env now = int(time.time()) # Collision if two demos start at exactly same second human = datetime.datetime.fromtimestamp(now).strftime('%a, %d %B %Y - %H:%M UTC') body['Metadata']['id'] = hashids.encode(now) body['Metadata']['timestart'] = now body['events'] = [{ "title": "", "raw": r"""<span class="event-message">Demo Started On {}</span>""".format(human), "id": 0 }] store_data(bucket, 'running/' + body['Metadata']['id'], json.dumps(body)) return respond(body=body)
def to_pk(hash_string): id_hash = Hashids(salt=settings.SECRET_KEY, min_length=12) pk = id_hash.decode(hash_string) if len(pk): return pk[0] else: return None
def gen_hash(registered_user): """Generates a time dependent hash. Accepts an instance of user account and returns a reversible 'time-unique' hash for it. Args: registered_user: A user instance. Returns: A hash composed of a time-stamp hash and a pk-hash delimited by x. """ # get a timestamp (to make each generated hash unique): timestamp = int(time() * 1000) # encode the timestamp with secret_key: hashids = Hashids( salt=UserHasher.secret_key, min_length=UserHasher.timehash_min_length, alphabet=UserHasher.alphabet ) timestamp_hash = hashids.encode(timestamp) # encode the user's pk with timestamp: hashids = Hashids( salt=str(timestamp), min_length=UserHasher.pkhash_min_length, alphabet=UserHasher.alphabet ) pk_hash = hashids.encode(registered_user.pk) # return the combination delimited by UserHasher.delim: return "%s%s%s" % (timestamp_hash, UserHasher.delim, pk_hash)
def test_single_number(self): h = Hashids() assert h.decrypt('rGAx') == (12345,) assert h.decrypt('yE') == (1,) assert h.decrypt('B8') == (22,) assert h.decrypt('7G9') == (333,) assert h.decrypt('zpz5') == (9999,)
def create(self, validated_data): bookmark = Bookmark.objects.create(**validated_data) hashids = Hashids('saltstring') hash = hashids.encode(bookmark.id) bookmark.hash_id = hash bookmark.save() return bookmark
def form_valid(self, form): hashids = Hashids(salt="donkeykongruleslwhisper") bookmark = form.save(commit=False) bookmark.hashid = hashids.encode(id(bookmark.url)) bookmark.user = self.request.user form.instance.created_by = self.request.user return super(CreateBookMarkView, self).form_valid(form)
def form_valid(self, form): bookmark = form.save(commit=False) hashstring = Hashids(salt=bookmark.link) linkhash = hashstring.encode(123456789) bookmark.shortlink = linkhash bookmark.user = self.request.user return super(AddBookmark, self).form_valid(form)
def hashid_to_int(hashid, min_length=11, salt=settings.RESPONSIVE_WRAPPER_HASHIDS_SALT): hashids = Hashids(salt, min_length=min_length) try: return hashids.decode(hashid)[0] except IndexError: pass
def hasher(): hashids = Hashids(salt='www.smokingpipes.com') hashid = hashids.encode(random.randint(1, 1000)) print(hashid) ints = hashids.decode('mVN') print(ints)
def forgotten_password(request): text_for_result = '' form = forgotten_password_form() if request.method == 'POST': form = forgotten_password_form(request.POST) if form.is_valid(): try: email = request.POST.get('email') member = Member.objects.filter(email=email)[0] memberUser = User.objects.filter(email=email)[0] hashids = Hashids() hashid = hashids.encrypt(member.password) memberUser.set_password(str(hashid)) member.password = str(hashid) if member: template = get_template("mail_forgotten_password.html") context = Context({'username': member.username, 'password': member.password}) content = template.render(context) mailgun_operator = mailgun() mailgun_operator.send_mail_with_html(member.email, content) text_for_result = 'We are send your password to your email. ' else: text_for_result = 'Wrong mail address.' return HttpResponseRedirect('/accounts/login') except Exception as e: print e return HttpResponseRedirect('/sorry') return render_to_response('forgotten_password.html', locals(), context_instance=RequestContext(request))
def gen_new_id(model): if model.find({}): hashids = Hashids(salt=SALT, min_length="6") id = model.find({}).count() + 1 return hashids.encrypt(id) else: raise "Model doesn'n exist"
def get_new_id(model): hashids = Hashids(salt=SALT, min_length="6") try: id = model.find({}).count() + 1 except: id = 0 return hashids.encrypt(id)
def hashid_to_int(hashid, min_length=11, salt=settings.DJANGOCMS_DISQUS_HASHIDS_SALT): hashids = Hashids(salt, min_length=min_length) try: return hashids.decode(hashid)[0] except IndexError: pass
def test_decode_hex(self): hex_str = '507f1f77bcf86cd799439011' assert Hashids().decode_hex('y42LW46J9luq3Xq9XMly') == hex_str h = Hashids(min_length=1000) assert h.decode_hex(h.encode_hex(hex_str)) == hex_str assert Hashids().decode_hex('WxMLpERDrmh25Lp4L3xEfM6WovWYO3IjkRMKR2ogCMVzn4zQlqt1WK8jKq7OsEpy2qyw1Vi2p') == \ 'f000000000000000000000000000000000000000000000000000000000000000000000000000000000000f'
def make_hash(instance): hashid = Hashids( min_length=10, salt=instance._meta.model_name, ) return hashid.encode(instance.id)
def genuid( salt=settings.SECRET_KEY, min_length=settings.UID_LENGTH, alphabet=settings.UID_ALPHABET ): hashids = Hashids(salt=salt, min_length=min_length, alphabet=alphabet) uid = hashids.encode(int(time() * 1000)) return uid
def cert_id_decode(key, hashid): hashids = Hashids(salt=key) try: cert_id = hashids.decode(hashid)[0] except IndexError: # Not encoded with the same key return None return cert_id
def __init__(self): self.print_env() self.hids = Hashids('qfpay')
def decode_url_string(url_string): h = Hashids(min_length=8, salt=settings.URL_SALT) result = h.decode(url_string) if result: return result[0]
def __generate_comment_id(self, target): hashids = Hashids(salt=os.environ['SALT_FOR_ARTICLE_ID'], min_length=settings.COMMENT_ID_LENGTH) return hashids.encode(target)
def url(self): hashids = Hashids(salt=settings.SECRET_KEY, min_length=10) return hashids.encode(self.id)
def hashid_encode(key, _id): hashids = Hashids(salt=key, min_length=6) hashid = hashids.encode(_id) return hashid
from django.shortcuts import get_object_or_404 from django.db.models import Q from django.db import models from django.core.validators import URLValidator from hashids import Hashids from os import environ import re from django.core.cache import cache SERVER_ADDR = environ.get("SERVER_ADDR", "http://127.0.0.1:8000") hashids = Hashids(salt='Hello, Avito', min_length=2) CACHE_TTL = 3600 class LinkManager(models.Manager): def get_object_or_404(self, hash, preferred_url): url_to_redirect = cache.get(hash) if url_to_redirect: return url_to_redirect url_to_redirect = cache.get(preferred_url) if url_to_redirect: return url_to_redirect url_to_redirect = get_object_or_404( Link,
from django.test import TestCase from hashids import Hashids from tests import models TEST_HASH_IDS = Hashids(salt="testing") class SerializerMixinTestCase(TestCase): """ Base test case to provide common functionality for serializer mixin tests. """ fixtures = ["test_data.json"] def setUp(self): super(SerializerMixinTestCase, self).setUp() self.manufacturer_tesla = models.Manufacturer.objects.get() self.carmodel_model_s = models.CarModel.objects.get() self.sku_p100d = models.Sku.objects.get(variant="P100D") self.sku_70 = models.Sku.objects.get(variant="70") self.owner_tyrell = models.Owner.objects.get() self.organization_ecorp = models.Organization.objects.get() @property def expected_complete_data(self): """ Return our expectation of the fully serialized model. """ return dict( id=self.carmodel_model_s.pk,
def encode(userid, time, postid): time = time.strftime("%y%m%d%H%M%S") hashids = Hashids() return base_link + hashids.encode(int(time), int(postid), int(userid))
def decode(code, object): hashids = Hashids() res = hashids.decode(code.replace(base_link, '')) if not res: return None return res[1]
def generate_short_url(url): return Hashids(salt=url).encode(random.randint(2, 999))
def post_save_bitlink(sender, instance, created, **kwargs): if created: hashids = Hashids(salt="bitlink", min_length=4) instance.shorten_hash = hashids.encode(instance.id) instance.save()
return "" return encodeIdList([id]) def decodeId(hash): if not hash: return None try: return decodeIdList(hash)[0] except: raise Http404 _encoder = Hashids(SECRET_KEY, 8) _idDict = {} _hashDict = {} def encodeIdList(idList): if not idList: return "" if len(idList) == 1 and int(idList[0]) < 1000000: id = int(idList[0]) encodedHash = _hashDict.get(id) if encodedHash == None: encodedHash = _encoder.encode(id) _idDict[encodedHash] = id _hashDict[id] = encodedHash
def __init__(self, name, salt='', min_length=0, alphabet=Hashids.ALPHABET): self.name = name self.salt = salt self.min_length = min_length self.alphabet = alphabet self._hashids = Hashids(salt=self.salt, min_length=self.min_length, alphabet=self.alphabet)
QINIU_ACCESS_KEY, QINIU_SECRET_KEY, QINIU_BUCKET, QINIU_BASE_URL, BASE_OUTPUT_DIR, BASE_OUTPUT_DUPLICATED_DIR, LEAN_APP_ID, LEAN_MASTER_KEY, HASH_SALT, HASH_MIN_LENGTH ) # 爬虫图片路径 SOURCE_SITE = "https://www.pexels.com" SOURCE_SITE_NAME = 'pexels' DOWNLOAD_DIR = os.path.join(BASE_OUTPUT_DIR, SOURCE_SITE_NAME) SOURCE_SITE_DUPLICATED = os.path.join(BASE_OUTPUT_DUPLICATED_DIR, SOURCE_SITE_NAME) START_PAGE = 1; CRAWL_BASE_URL = "https://www.pexels.com/popular-photos.js?page=" hashids = Hashids(salt=HASH_SALT, min_length=HASH_MIN_LENGTH) # 弃用了,现在改成执行 aria2c 命令下载了 def downloadImg(url, name): print "name=%s, url=%s" % (name, url) path = "./%s" % name if os.path.exists(path): return headers = {'User-Agent':'Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/37.0.2049.0 Safari/537.36'} req = urllib2.Request(url, headers=headers) data = urllib2.urlopen(req).read() f = file(path, "wb") f.write(data) f.close() def parsePage(page):
def _validation_hash(analysis_id): """ Create a validation hash for the analysis """ return Hashids(current_app.config['SECONDARY_HASH_SALT'], min_length=10).encode(analysis_id)
def key(): hashids = Hashids(salt=salt) id = hashids.encode(random.randint(0, 100000000000), random.randint(0, 100000000000), random.randint(0, 100000000000)) return id
# and then saves it in the 'cached' collection in the dB # It has the following wrapper functions – # 1. Do it for all links in the 'core' collection # 2. Do it for a single link # 3. Store the cached article in the dB import pymongo myclient = pymongo.MongoClient('127.0.0.1', 27017) mydb = myclient['buzodog'] mycol = mydb['cached'] import argparse import logging as log from hashids import Hashids hashids = Hashids(min_length=12, salt='thatbuzo') import requests from bs4 import BeautifulSoup from pprint import pprint as pp try: from . import helper except: import helper ### Create a backup def backup(): mycol = mydb['cache']
def _serializer(self): return Hashids(self.salt, self.min_length)
def encode_seeds(seeds): """ Generate UID from a list of seeds. """ from hashids import Hashids hashids = Hashids(salt="TextWorld") return hashids.encode(*seeds)
def order_product_serialize(order_product): serializer = Hashids(min_length=5, salt=SALT_ORDER_PRODUCT) token = serializer.encode(order_product.id) return token
def add_booking(self, order_dict, user_id): try: session = Session() holder = IntermediateValueHolder() if not 'lnkKey' in order_dict: print 'NO BOOKING ID - lnkKey' print '*' * 100 return store_key = order_dict['lnkKey'] obj = holder.retrieve(store_key) if obj == None: return [], False master_id = obj['master_id'] dates = obj['dates'] time = obj['time'] cleaning_duration = obj['cleaning_duration'] additional_time = 0 if 'additional_time' in obj: additional_time = obj['additional_time'] order_id = order_dict['ordNo'] product_no = order_dict['sellerPrdNo'] if '_' in product_no: product_no = product_no.split('_') appointment_type = int(product_no[2]) else: appointment_type = 0 # field request_id = str(uuid.uuid4()) #appointment_type = int(product_no[2]) message = order_dict[ 'rsvEtcInfo5'] if 'rsvEtcInfo5' in order_dict else '' trash_location = '%s %s' % (order_dict['rsvEtcInfo1'], order_dict['rsvEtcInfo2']) havepet = 0 if order_dict['rsvEtcInfo3'] == '아니오' else 1 card_idx = -1 addr_idx = 0 options = order_dict['RsvDtlsInfo'] print options options_price = sum([int(opt['optAmt']) for opt in options[1:]]) options_name = [opt['optNm'] for opt in options[1:]] additional_task = 0 if options_name != [None]: for opt in options_name: if '창문' in opt: additional_task += 1 elif '베란다' in opt: additional_task += 2 elif '빨래' in opt: additional_task += 4 elif '옷장' in opt: additional_task += 8 elif '단문형' in opt: additional_task += 16 elif '양문형' in opt: additional_task += 32 actual_price = int(order_dict['rsvAmt']) price = actual_price - options_price now = dt.datetime.strftime(dt.datetime.now(), '%Y%m%d%H%M%S') hashids = Hashids(min_length=16, salt=now + user_id) booking_ids = [] index = 1 for date in dates: # print date, time if index == 1: booking_id = store_key else: booking_id = hashids.encode( int(date + time.replace(':', ''))) print 'key', booking_id date = dt.datetime.strptime(date, '%Y%m%d') dow = date.date().weekday() booking_time = dt.time(hour=int(time.split(':')[0]), minute=int(time.split(':')[1])) start_time = dt.datetime.combine(date, booking_time) estimated_end_time = start_time + dt.timedelta( minutes=cleaning_duration + additional_time) if index != 1: actual_price = price additional_task = 0 estimated_end_time -= dt.timedelta(minutes=additional_time) booking = Booking( id=booking_id, request_id=request_id, user_id=user_id, master_id=master_id, appointment_type=appointment_type, appointment_index=index, dow=dow, booking_time=dt.datetime.now(), org_start_time=start_time, start_time=start_time, estimated_end_time=estimated_end_time, end_time= estimated_end_time, # update after homemaster finish their job cleaning_duration=cleaning_duration, additional_task=additional_task, price=price, price_with_task=actual_price, charging_price=0, card_idx=card_idx, addr_idx=addr_idx, message=message, trash_location=trash_location, havepet=havepet, laundry_apply_all=0, is_dirty=0, master_gender=0, source='11st', status=BC.BOOKING_UPCOMMING, cleaning_status=BC.BOOKING_UPCOMMING, payment_status=BC.BOOKING_PAID) session.add(booking) index += 1 booking_ids.append(booking_id) # remove store_key and related_keys store_key = obj['store_key'] search_keys = obj['search_keys'].split(',') holder.remove(store_key) for sk in search_keys: holder.remove(sk) # order_11st에 order_id 추가 필요. print order_id order = Order11st(order_id=order_id) session.add(order) session.commit() except Exception, e: print_err_detail(e)
def initHashids(): return Hashids(salt=app.config['HASHSALT'], min_length=app.config['HASHLENGTH'])
def decode_url(self, url): hashids = Hashids(salt=settings.SECRET_KEY, min_length=10) decoded = hashids.decode(url) if not decoded: raise Exception("Could not decode hashid to pk") return decoded[0]
from hashids import Hashids hashids = Hashids(salt='9d30d9e3fe2a02c5dba90a4fa9c1cd649e60eac2', min_length=6) def generate_hash(link_id): return hashids.encode(link_id) def decode_hash(hash): return hashids.decode(hash)
def hashid_decode(key, hashid): hashids = Hashids(salt=key, min_length=6) _id = hashids.decode(hashid) return _id[0]
def save(self,*arg,**kwargs): super().save(*arg,**kwargs) if not self.codigo: self.codigo=Hashids(min_length=4,alphabet="abcdefghijklmnopqrstuvwxyz").encode(self.pk) self.save()
#!/usr/bin/env python # encoding: utf-8 from gmission.config import APP_SECRET_KEY from gmission.controllers.async_jobs_controller import send_reg_email_async __author__ = 'rui' from hashids import Hashids import time hashids = Hashids(salt=APP_SECRET_KEY, min_length=32) HASHID_EXPIRE_TIME = 60 * 60 * 24 * 2 # 2 days def generate_user_auth_hashid(id): hashid = hashids.encode(id, int(time.time()) + HASHID_EXPIRE_TIME) return hashid def get_id_from_user_auth_hashid(hashid): id = hashids.decode(hashid) if len(id) == 2: return int(id[0]), int(id[1]) else: return 0 def send_user_auth_email(user): if user is None: return if user.active:
def decode_enlace(self,codigo): decode = Hashids(min_length=4, alphabet="abcdefghijklmnopqrstuvwxyz").decode(codigo)[0] self.filter(pk=decode).update(contador=models.F('contador')+1) return self.filter(pk=decode).first().url
# coding:utf-8 import time import json import redis from hashids import Hashids from requests import post, get from functools import wraps from huepy import red, info, lightpurple, purple redis_pool = redis.Redis('172.100.101.156') hids = Hashids('qfpay') env = 'debug' # env = 'product' # env = 'qa' SKEY = 'test_org_sid' CUSTOMER_ID = 24 if env == 'product': HOST = 'https://o.qa.qfpay.net' USERNAME = 14400001234 # 12 PASSWORD = '******' elif env == 'qa': HOST = 'https://o.qa.qfpay.net' USERNAME = 14700000291
# -*- coding: utf-8 -*- from datetime import date, datetime import calendar import csv, json import time, random from hashids import Hashids hashids = Hashids() #Path vars HWPath = "../HomeWorks/" TTPath = "../Datas/" DBFile = "../homework.db" #List vars Weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"] TimeTable = [] todayLessons = [] class HomeWork: def __init__(self, date, nextLessonDate, hw, lesson, id): self.date = date self.nextLessonDate = nextLessonDate self.hw = hw self.lesson = lesson self.id = id with open(TTPath + "schedule.json") as ScheduleFile: Schedule = json.load(ScheduleFile)