class NumSystemConvertor(object):
crypto_chars = ('abcdefghkmnpqrstwxyz' 'ABCDEFGHKMNPQRSTWXYZ' '23456789')
engine = BaseConverter(crypto_chars)
@classmethod
def encode(cls, dec_num):
return cls.engine.encode(dec_num)
@classmethod
def decode(cls, val):
return cls.engine.decode(val)
def __init__(self, proxies={}):
# Create new session
self.request_session = requests.Session()
self.proxies = proxies
# Use header that makes it seem less like a bot
self.headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36",
"Accept-Language": "en-US,en;q=0.8",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"}
# repl base is A-Z0-9a-z
repl_it_string = string.ascii_uppercase + string.digits + string.ascii_lowercase
self.repl_it_base = BaseConverter(repl_it_string)
def get_uid():
interfaces = netifaces.interfaces()
interfaces.sort()
i = interfaces[0]
s = "abcdefghijklmnopqrstuvwxyz"
u = "ABCDEFGHJKLMNPQRSTUVWXYZ"
d = "0123456789"
bc = BaseConverter(d+s+u)
hashid = hashlib.sha1(i.encode("utf-8")).hexdigest()
hashid = hashid.upper()
raw = base16.decode(hashid)
uid = bc.encode(raw)
return uid
class IdEncoder(object):
_base26 = BaseConverter('1#$MYBKRAVJNLGT95C6S4DU8PXQHIW3E2F7Z')
_base26r = BaseConverter('5GBHX$Z3A1MEQCT#NSYKIR48U7FJ692VPDWL')
@classmethod
def encode(cls, n):
return cls._base26.encode(n)+cls._base26r.encode(n)
@classmethod
def decode(cls, n):
n = n.upper()
m = len(n)/2
try:
id1 = cls._base26.decode(n[:m])
except (IndexError, ValueError):
return
try:
id2 = cls._base26r.decode(n[m:])
except (IndexError, ValueError):
return
if id1 == id2:
return id1
def find_prime(f, base, res):
conv = BaseConverter(('').join(map(str, [tmp for tmp in range(0, base)])))
f = int(conv.decode(f))
if base == 10:
factor = get_prime_factor(f)
if factor:
res.append(factor)
return True
else:
return False
factor = get_prime_factor(f)
if factor:
res.append(factor)
return find_prime(conv.encode(f), base + 1, res)
else:
return False
def is_jam_coin(f, base, primes, res):
conv = BaseConverter(('').join(map(str, [tmp for tmp in range(0, base)])))
f = int(conv.decode(f))
if base == 10:
factor = find_prime_fact(f, primes)
if factor:
res.append(factor)
return True
else:
return False
factor = find_prime_fact(f, primes)
if factor:
res.append(factor)
return is_jam_coin(conv.encode(f), base + 1, primes, res)
else:
return False
def __init__(
self,
state: int = 0,
prefix: str = "",
length: int = 4,
alphabet: str = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',
) -> None:
""" Create a new id converter with a given state and alphabet. """
self.state = state
self.prefix = prefix
self.length = length
self.alphabet = alphabet
from baseconv import BaseConverter
self.converter = BaseConverter(alphabet)
return
def main():
for t in range(int(input())):
print('Case #%d:' % (t + 1))
n, j = map(int, input().split(' '))
#print(('').join(map(str, [ tmp for tmp in range(0, x) ])))
#conv = BaseConverter(('').join(map(str, [ tmp for tmp in range(0, x) ])))
#s = ('%s1' % (('').join(map(str, [0 for tmp in range(0, n-2)]))))
b2 = BaseConverter('01')
f = b2.encode(pow(2, n - 1) + 1)
f = pow(2, n - 1) + 1
found = 0
while found < j:
res = []
if find_prime(b2.encode(f), 2, res):
print('%s %d %d %d %d %d %d %d %d %d' %
(b2.encode(f), res[0], res[1], res[2], res[3], res[4],
res[5], res[6], res[7], res[8]))
found += 1
f += 2
import sys
import rethinkdb as r
from . import db
from . import login_manager, bcrypt
from baseconv import BaseConverter
from flask_login import UserMixin
from random import SystemRandom
characters = 'abcdefghkmnpqrstwxyz'
digits = '23456789'
base = characters + characters.upper() + digits
number_converter = BaseConverter(base)
def id_generator():
return SystemRandom().randint(1, sys.maxsize)
def gen_short_id(long_id):
return number_converter.encode(long_id)
def get_long_id(short_id):
return number_converter.decode(short_id)
class DataBase:
def __init__(self, db):
case_end)
print f, '-->', outpath
output = open(os.path.join(cur_dir, outpath), 'w')
break
start = time.time()
# -------------------------------------------------------
from baseconv import BaseConverter
convs = [None, None]
for i in range(2, 11):
s = "".join(str(j) for j in range(i))
print s
convs.append(BaseConverter(s))
def jams(n):
vals = []
for i in range(2, 11):
vals.append(int(convs[i].decode(n)))
return vals
def is_prime(num):
for j in range(2, int(math.sqrt(num) + 1)):
if (num % j) == 0:
return j
return 0
from collections import namedtuple
from baseconv import BaseConverter
from icq.constant import ImageType, VideoType, AudioType
BASE62_ICQ_CONVERTER = BaseConverter(
"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
def decode_file_id(file_id):
type_ = file_id[0]
for t in (ImageType, VideoType, AudioType):
try:
type_ = t(type_)
break
except ValueError:
pass
else:
raise ValueError("Unknown file type '{}'!".format(type_))
cls = type(type_)
width = height = length = None
if cls in (ImageType, VideoType):
width = int(BASE62_ICQ_CONVERTER.decode(file_id[1:3]))
height = int(BASE62_ICQ_CONVERTER.decode(file_id[3:5]))
elif cls is AudioType:
length = int(BASE62_ICQ_CONVERTER.decode(file_id[3:5]))
return namedtuple("DecodedFileID",
("type", "width", "height", "length"))(type_, width,
from baseconv import BaseConverter
import random
primary_numbers = []
secondary_numbers = []
outputs = []
for i in xrange(25):
ternary_string1 = ""
for j in xrange(random.randint(50, 100)):
ternary_string1 += str(random.randint(0, 2))
ternary_string2 = ""
for j in xrange(random.randint(50, 100)):
ternary_string2 += str(random.randint(0, 2))
base3 = BaseConverter("012")
decimal_string1 = base3.decode(ternary_string1)
decimal_string2 = base3.decode(ternary_string2)
decimal_output = int(decimal_string1) - int(decimal_string2)
ternary_output = base3.encode(str(decimal_output))
input = ternary_string1 + "#" + ternary_string2
expected_output = ternary_output
print "Input:"
print input
print "Expected Output:"
print expected_output
print
from baseconv import BaseConverter, BASE16_ALPHABET
from uuid import UUID, uuid4
BASE = 16
HEX_DOUBLE_WORD_LENGTH = 8
HEX_DOUBLE_WORD_UPPER_BYTE = slice(-HEX_DOUBLE_WORD_LENGTH,
-(HEX_DOUBLE_WORD_LENGTH - 2))
MAX_DOUBLE_WORD = (1 << 31)
OLD_BIT_FLAG = 0x80
NEW_BIT_FLAG_MASK = OLD_BIT_FLAG - 1
BASE16 = BaseConverter(BASE16_ALPHABET.lower())
class UUIDGenerator():
uuid = None
def __init__(self):
while True:
uuid = uuid4()
replacer = BASE16.encode(
int(BASE16.decode(str(uuid)[HEX_DOUBLE_WORD_UPPER_BYTE]))
& NEW_BIT_FLAG_MASK)
if int(replacer, BASE) >= 16:
break
self.uuid = UUID(
str(uuid)[:-(HEX_DOUBLE_WORD_LENGTH)] + replacer +
str(uuid)[-(HEX_DOUBLE_WORD_LENGTH - 2):])
@staticmethod
def new_version(uuid):
return not bool(
from baseconv import BaseConverter
string =['2d', '33', '2g', '1i', '2c', '31', '4f', '20', '1p', '3e', '1o',
'3n', '3e', '1l', '3e', '3i', '1p', '46', '1p', '40', '3n', '1l', '3e', '1p',
'45', '49', '1m', '3e', '1o', '3n', '3e', '3h', '3g', '47', '3k', '3e', '1n',
'21', '4h'];
full = '0123456789abcdefghijklmnopqrstuvxwyz'
size = len(full)
zero = 0
for i in string:
if ord(i[1]) > zero:
zero = ord(i[1])
for i in range((full.find(chr(zero)) + 1), size):
base = BaseConverter(full[0:i])
result = []
for j in string:
result.append(int(base.decode(j)))
text = ''.join(chr(c) for c in result)
print text
from baseconv import BaseConverter
x = 0.01
encoder_base = BaseConverter('USD')
filter_ranges = [
{
'range': (-100, -3 * x),
'label': 'D'
},
{
'range': (-3 * x, -2 * x),
'label': 'D'
},
{
'range': (-2 * x, -x),
'label': 'D'
},
{
'range': (-x, x),
'label': 'S'
},
{
'range': (x, 2 * x),
'label': 'U'
},
{
'range': (2 * x, 3 * x),
'label': 'U'
},
{
from random import SystemRandom
from baseconv import BaseConverter
import sys
import re
from peewee import IntegrityError
import os
import json
from datetime import datetime, timedelta
import settings
from database import db, Dump
GOOD_CHARS = 'abcdefghkmnpqrstwxyz'
GOOD_DIGITS = '23456789'
CRYPTO_CHARS = GOOD_CHARS + GOOD_CHARS.upper() + GOOD_DIGITS
NUM_SYSTEM_CONVERTOR = BaseConverter(CRYPTO_CHARS)
APP = Bottle()
TIMEOUT_MAP = {
'm10': timedelta(minutes=10),
'h1': timedelta(hours=1),
'd1': timedelta(days=1),
'd7': timedelta(days=7),
'd30': timedelta(days=30),
}
def create_dump(data, expires):
gen = SystemRandom()
for x in range(10):
new_id = gen.randint(1, sys.maxsize)
try:
# https://github.com/semente/python-baseconv
from baseconv import base2, base16, base36, base56, base58, base62, base64, BaseConverter
import pyperclip
import time
# from my img2.py
PROGRAM_NAME = "quickDecode"
PROGRAM_NAME_SHORT = "kwdec"
BAD = "Inconvertable :("
ASCII = ''.join(chr(x) for x in range(256))
ASCII_base = BaseConverter(ASCII, sign='ё') # umlaut e is for failsafe
# https://stackoverflow.com/a/3368991
def find_between(s, first, last):
try:
start = s.index(first) + len(first)
end = s.index(last, start)
return s[start:end]
except ValueError:
return ""
def find_between_r(s, first, last):
try:
start = s.rindex(first) + len(first)
def _base_converter_init(alphabet):
"""."""
from baseconv import BaseConverter
converter = BaseConverter(alphabet)
return converter
