示例#1
0
    async def bitly(self, ctx, *, link):
        try:
            access_token = os.environ.get("bitly_access_token")
            access_token = [access_token]

            shortener = Shortener(tokens=access_token, max_cache_size=8192)
            shortened_link = shortener.shorten_urls([link])

            embed = discord.Embed(color=self.bot.embed_color,
                                  title="→ URL Shortener")
            embed.add_field(name="• Long link:", inline=False, value=link)
            embed.add_field(name="• Shortened link:",
                            inline=False,
                            value=shortened_link[0])

            await ctx.send(embed=embed)

            logger.info(
                f"Utility | Sent Bitly: {ctx.author} | Long link: {link} | Shortened Link: {shortened_link[0]}"
            )
        except Exception:
            embed = discord.Embed(
                color=self.bot.embed_color,
                title="→ Invalid URL",
                description="• Please put a valid URL!"
                "\n• Example: `l!shortenlink https://google.com`")

            await ctx.send(embed=embed)
            ctx.command.reset_cooldown(ctx)
示例#2
0
async def shortener(short):
    """
        Shorten link using bit.ly API
    """
    if BITLY_TOKEN is not None:
        token = [f'{BITLY_TOKEN}']
        reply = await short.get_reply_message()
        message = short.pattern_match.group(1)
        if message:
            pass
        elif reply:
            message = reply.text
        else:
            await short.edit("`Error! No URL given!`")
            return
        link_match = match(r'\bhttps?://.*\.\S+', message)
        if link_match:
            pass
        else:
            await short.edit(
                "`Error! Please provide valid url!`\nexample: https://google.com"
            )
            return
        urls = [f'{message}']
        bitly = Shortener(tokens=token, max_cache_size=8192)
        raw_output = bitly.shorten_urls(urls)
        string_output = f"{raw_output}"
        output = string_output.replace("['", "").replace("']", "")
        await short.edit(
            f"`Your link shortened successfully!`\nHere is your link {output}")
    else:
        await short.edit(
            f"Set bit.ly API token first\nGet from [here](https://bitly.com/a/sign_up)"
        )
示例#3
0
    def post(self, request, *args, **kwargs):
        vendor = request.user.vendor

        form = SMSCampaignForm(request.data)

        if form.is_valid():
            campaign = form.save(commit=False)
            campaign.vendor = vendor
            campaign.save()
            campaign.to.add(*request.data['to'])

            URL = 'https://api.smsmode.com/http/1.6/'
            PATH_SEND_SMS = "sendSMS.do"

            sms_sent = 0

            tokens_pool = [os.environ.get('BITLY_API_KEY')]
            shortener = Shortener(tokens=tokens_pool, max_cache_size=8192)

            for customer in Customer.objects.filter(pk__in=request.data['to']):
                links = shortener.shorten_urls([
                    'https://app.kustomr.fr/welcome/{}-{}/{}'.format(
                        vendor.pk, slugify(vendor.store_name),
                        customer.token.token)
                ])
                final_url = (
                    URL + PATH_SEND_SMS + '?accessToken=' +
                    settings.SMSMODE_API_KEY + '&date_envoi=' +
                    datetime.strptime(
                        request.data['send_at'],
                        "%Y-%m-%d %H:%M").strftime('%d%m%Y-%H:%m') +
                    '&message=' + urllib.parse.quote_plus(
                        (request.data['content'] + '\nMon profil: {}'.format(
                            links[0])).encode('iso-8859-15')) + '&numero=' +
                    customer.phone + '&emetteur=' +
                    slugify(vendor.store_name).replace('_', '').upper()[:11] +
                    '&stop=1')
                r = requests.get(final_url)
                if r:
                    sms_sent += 1

            if sms_sent == 0:
                return Response(
                    {'message': 'Impossible de programmer la campagne SMS.'},
                    status=status.HTTP_400_BAD_REQUEST)
            campaign.sent = True
            campaign.save()
            return Response(
                {
                    'message':
                    'L\'envoi de {} SMS a été programmé.'.format(sms_sent)
                },
                status=status.HTTP_200_OK)

        else:
            print(form.errors)
            return Response(
                {'message': 'Impossible de valider le formulaire.'},
                status=status.HTTP_400_BAD_REQUEST)
示例#4
0
def linkshorten(linkbeforeshorten):
    tokens_pool = ['90e741cf3ceec9f9eb6b87b911ae42a007d4d6d3']  # Use your own.
    shortener = Shortener(tokens=tokens_pool, max_cache_size=8192)

    # Shorten to list

    urls = [linkbeforeshorten]
    return (shortener.shorten_urls(urls))
def shorten_url(url):
    shortener = Shortener(tokens=BITLY_ACCESS_TOKEN, max_cache_size=8192)

    if any('reddit' in s for s in url):
        link = shortener.shorten_urls(url)
    else:
        link = url
    return link
def shorten_address(url):
    tokens_pool = ['a2039c392dd9545fc3df1002a4441d9dfc534797']
    shortener = Shortener(tokens=tokens_pool, max_cache_size=8192)

    urls = [url]

    result = shortener.shorten_urls_to_dict(urls)

    return result
示例#7
0
async def bitly(_client, message):
    args = message.text.split(None, 1)
    shortener = Shortener(tokens=bitly_token, max_cache_size=8192)
    if len(args) == 1:
        await message.edit("Usage bitly (url)!")
        return
    if len(args) == 2:
        await message.edit("Processing")
        urls = [args[1]]
        shortlink = shortener.shorten_urls(urls)
        await message.edit("Here Your link\n{}".format(shortlink[0]), disable_web_page_preview=True)
示例#8
0
 def __init__(self, client: Client):
     self.client = client
     self.user_flows = {}
     self.scopes = [
         "https://www.googleapis.com/auth/calendar.readonly",
         "https://www.googleapis.com/auth/gmail.readonly"
     ]
     with open("api.json", "r") as f:
         f = load(f)
         cluster = MongoClient(f.get("mongodb"))
         self.users = cluster["discord"]["users"]
         self.shortener = Shortener(tokens=[f.get("bitly")])
 def __init__(self,url,title,reponame) :
      ThermalPrinter = adafruit_thermal_printer.get_printer_class(2.69)
      uart = serial.Serial("/dev/ttyS0", baudrate=19200, timeout=3000)
      self._printer = ThermalPrinter(uart)
      self._printer.warm_up()
      shortener = Shortener(tokens=tokens_pool, max_cache_size=8192)
      urls = [url]
      self._urlshort = shortener.shorten_urls(urls)
      self._last = url.rfind('/')
      self._n_issue = url[self._last+1:len(url)]
      qrcode_image = qrcode.make(self._urlshort[0])
      self._qrcode_logo = '/home/pi/qrcode.png'
      qrcode_image.save(self._qrcode_logo)
      self._title = title
      self._repository = reponame
示例#10
0
async def shorten(msg):
    if msg.get('text'):
        if msg['text'].startswith('/shorten'):
            text = msg['text'][9:]
            if not text:
                await bot.sendMessage(msg['chat']['id'],'*Uso:* `/shorten https://google.com` - _Encurta uma URL. ','Markdown',  reply_to_message_id=msg['message_id'])
            else:
                if not text.startswith('http://') or not text.startswith('https://'):
                    texto = 'https://' + text
                    try:
                        #sistema do pipy acima
                        tokens_pool = ["a001cef9d44ed8083ed4d952d475e98079e60577", ]
                        shortener = Shortener(tokens=tokens_pool, max_cache_size=8192)
                        urls = [texto]
                        a = shortener.shorten_urls(urls)
                        await bot.sendMessage(msg['chat']['id'], '*Link Encurtado:* {}'.format(a[0]), 'Markdown', reply_to_message_id=msg['message_id'])
                    except:
                        await bot.sendMessage(msg['chat']['id'], '`Não foi possivel encurtar seu link, tente enviando com http ou https, talves o serviço esteja offline.`', 'Markdown', reply_to_message_id=msg['message_id'])
            return True
示例#11
0
async def shortener(short):
    """
    Shorten link using bit.ly API
    """
    if BIT_TOKEN is not None:
        token = [f"{BIT_TOKEN}"]
        reply = await short.get_reply_message()
        message = short.pattern_match.group(1)
        if message:
            pass
        elif reply:
            message = reply.text
        else:
            await eor(short, "`Error! No URL given!`")
            return
        link_match = match(r"\bhttps?://.*\.\S+", message)
        if not link_match:
            await eor(
                short,
                "`Error! Please provide valid url!`\nExample: https://google.com"
            )
            return
        urls = [f"{message}"]
        bitly = Shortener(tokens=token, max_cache_size=8192)
        raw_output = bitly.shorten_urls(urls)
        string_output = f"{raw_output}"
        output = string_output.replace("['", "").replace("']", "")
        await eor(
            short,
            f"`Your link shortened successfully!`\nHere is your link {output}")
        if BOTLOG:
            await short.client.send_message(
                PRIVATE_GROUP_ID, f"`#SHORTLINK \nThis Your Link!`\n {output}")
    else:
        await eor(
            short,
            "Set bit.ly API token first\nGet it from [here](https://bitly.com/a/sign_up)",
        )
示例#12
0
    "https://arxiv.org/abs/1902.01030v1",
    "https://arxiv.org/abs/1902.00916v1",
    "https://arxiv.org/abs/1902.00908v1",
    "https://arxiv.org/abs/1902.00771v1",
    "https://arxiv.org/abs/1902.00719v1",
    "https://arxiv.org/abs/1902.00685v1",
    "https://arxiv.org/abs/1902.00672v1",
    "https://arxiv.org/abs/1902.00659v1",
    "https://arxiv.org/abs/1902.00655v1",
    "https://arxiv.org/abs/1902.00626v1",
    "https://arxiv.org/abs/1902.00624v1",
    "https://arxiv.org/abs/1902.00604v1",
    "https://arxiv.org/abs/1902.00577v1",
    "https://arxiv.org/abs/1902.00541v1",
]

# URLs = ["https://j.mp/websniffer", "http://j.mp/2Bo2LVf", "http://bit.ly/2BombJQ", "https://cnn.it/2Ggb2ih"]

try:
    shortener = Shortener(tokens=TOKENS, max_cache_size=128)
    urls = random.sample(URLs, k=min(len(URLs), {"none": 0, "one": 1, "some": 3, "all": len(URLs)}["one"]))
    print(shortener.shorten_urls(urls))
    # print(shortener.usage())
    print(shortener.shorten_urls(urls))
    # print(shortener.usage())
    # print(shortener.shorten_urls_to_dict(urls[::-1]))

except Exception:
    time.sleep(0.01)  # Delay for longs to flush.
    raise
示例#13
0
async def link_direto(msg):
    try:
        chat_id = msg['chat']['id']
        chat_type = msg['chat']['type']
        texto = msg['text']
        tokens_pool = [
            "a001cef9d44ed8083ed4d952d475e98079e60577",
        ]
        shortener = Shortener(tokens=tokens_pool, max_cache_size=8192)
        if chat_type == 'supergroup':
            try:  # DOCUMENTOS
                if 'document' in msg.get(
                        'reply_to_message'
                ) and texto == '/link' or 'document' in msg.get(
                        'reply_to_message') and texto == 'link':
                    #if adm['user'] == True:
                    id_documento = msg.get(
                        'reply_to_message')['document']['file_id']
                    nome = msg.get('reply_to_message')['document']['file_name']
                    arquivo = await bot.getFile(id_documento)
                    tamanho = arquivo['file_size']
                    link = f"https://api.telegram.org/file/bot{token}/{arquivo['file_path']}"
                    try:
                        a = shortener.shorten_urls([link])
                        await bot.sendMessage(
                            chat_id,
                            f"🤖 Aqui está seu link direto.\nArquivo:{nome}\nTamanho:{tamanho}\nLink:{a[0]}",
                            reply_to_message_id=msg['message_id'])
                    except:
                        await bot.sendMessage(
                            msg['chat']['id'],
                            '`Não foi possivel encurtar seu link, tente novamente, talves o serviço esteja offline.`',
                            'Markdown',
                            reply_to_message_id=msg['message_id'])
            except Exception as e:
                pass

            try:  # IMAGENS
                if 'photo' in msg.get(
                        'reply_to_message'
                ) and texto == '/link' or 'photo' in msg.get(
                        'reply_to_message') and texto == 'link':
                    #if adm['user'] == True:
                    id_foto = msg.get(
                        'reply_to_message')['photo'][0]['file_id']
                    nome = 'imagem'
                    arquivo = await bot.getFile(id_foto)
                    tamanho = arquivo['file_size']
                    link = f"https://api.telegram.org/file/bot{token}/{arquivo['file_path']}"
                    try:
                        a = shortener.shorten_urls([link])
                        await bot.sendMessage(
                            chat_id,
                            f"🤖 Aqui está seu link direto.\nArquivo:{nome}\nTamanho:{tamanho}\nLink:{a[0]}",
                            reply_to_message_id=msg['message_id'])
                    except:
                        await bot.sendMessage(
                            msg['chat']['id'],
                            '`Não foi possivel encurtar seu link, tente novamente, talves o serviço esteja offline.`',
                            'Markdown',
                            reply_to_message_id=msg['message_id'])
            except Exception as e:
                pass

            try:  # AUDIOS
                if 'audio' in msg.get(
                        'reply_to_message'
                ) and texto == '/link' or 'audio' in msg.get(
                        'reply_to_message') and texto == 'link':
                    id_documento = msg.get(
                        'reply_to_message')['audio']['file_id']
                    nome = msg.get('reply_to_message')['audio']['title']
                    arquivo = await bot.getFile(id_documento)
                    tamanho = arquivo['file_size']
                    link = f"https://api.telegram.org/file/bot{token}/{arquivo['file_path']}"
                    try:
                        a = shortener.shorten_urls([link])
                        await bot.sendMessage(
                            chat_id,
                            f"🤖 Aqui está seu link direto.\nArquivo:{nome}\nTamanho:{tamanho}\nLink:{a[0]}",
                            reply_to_message_id=msg['message_id'])
                    except:
                        await bot.sendMessage(
                            msg['chat']['id'],
                            '`Não foi possivel encurtar seu link, tente novamente, talves o serviço esteja offline.`',
                            'Markdown',
                            reply_to_message_id=msg['message_id'])
            except Exception as e:
                pass

            try:  # VIDEOS
                if 'video' in msg.get(
                        'reply_to_message'
                ) and texto == '/link' or 'video' in msg.get(
                        'reply_to_message') and texto == 'link':
                    id_documento = msg.get(
                        'reply_to_message')['video']['file_id']
                    nome = 'video'
                    arquivo = await bot.getFile(id_documento)
                    tamanho = arquivo['file_size']
                    link = f"https://api.telegram.org/file/bot{token}/{arquivo['file_path']}"
                    try:
                        a = shortener.shorten_urls([link])
                        await bot.sendMessage(
                            chat_id,
                            f"🤖 Aqui está seu link direto.\nArquivo:{nome}\nTamanho:{tamanho}\nLink:{a[0]}",
                            reply_to_message_id=msg['message_id'])
                    except:
                        await bot.sendMessage(
                            msg['chat']['id'],
                            '`Não foi possivel encurtar seu link, tente novamente, talves o serviço esteja offline.`',
                            'Markdown',
                            reply_to_message_id=msg['message_id'])
            except Exception as e:
                pass

            try:  # VOZ
                if 'voice' in msg.get(
                        'reply_to_message'
                ) and texto == 'link' or 'voice' in msg.get(
                        'reply_to_message') and texto == '/link':
                    id_documento = msg.get(
                        'reply_to_message')['voice']['file_id']
                    nome = f"audio do {msg['from']['first_name']}"
                    arquivo = await bot.getFile(id_documento)
                    #tamanho = arquivo['file_size']
                    link = f"https://api.telegram.org/file/bot{token}/{arquivo['file_path']}"
                    try:
                        a = shortener.shorten_urls([link])
                        await bot.sendMessage(
                            chat_id,
                            f"🤖 Aqui está seu link direto.\nArquivo:{nome}\nLink:{a[0]}",
                            reply_to_message_id=msg['message_id'])
                    except:
                        await bot.sendMessage(
                            msg['chat']['id'],
                            '`Não foi possivel encurtar seu link, tente novamente, talves o serviço esteja offline.`',
                            'Markdown',
                            reply_to_message_id=msg['message_id'])
            except Exception as e:
                pass

    except Exception as e:
        pass
示例#14
0
#-------------------------------------------------------------------- user defined variables

extPath = 'C:/Users/ethom/Desktop/'  # where the user wants to control files from
intPath = 'E:/Aura/'  # where the individual aura files are stored
bitkey = ['']  # bit.ly api key

#-------------------------------------------------------------------- other variables

now = datetime.now(
)  # make it so i can use datetime.now instead of datetime.datetime.now
gt = Translator()  # define gt as a command for google translate
wiki = wikipediaapi.Wikipedia(
    'en')  # define wiki as a command, setting the language
shortener = Shortener(
    tokens=bitkey,
    max_cache_size=8192)  # define shortener as a command using the bit.ly key
new = 2  # I haven't found a way to use webbrowser.open() without using variables yet

#-------------------------------------------------------------------- return without variable


def openProgramsCheck():
    EnumWindows = ctypes.windll.user32.EnumWindows
    EnumWindowsProc = ctypes.WINFUNCTYPE(ctypes.c_bool,
                                         ctypes.POINTER(ctypes.c_int),
                                         ctypes.POINTER(ctypes.c_int))
    GetWindowText = ctypes.windll.user32.GetWindowTextW
    GetWindowTextLength = ctypes.windll.user32.GetWindowTextLengthW
    IsWindowVisible = ctypes.windll.user32.IsWindowVisible
    titles = []
from flask_migrate import Migrate
from flask_sqlalchemy import SQLAlchemy
from bitlyshortener import Shortener
from dotenv import load_dotenv

sys.path.append(os.path.dirname(__file__))
sys.path.append(os.path.join(os.path.dirname(__file__), 'app'))
sys.path.append(
    os.path.join(os.path.dirname(__file__), os.path.join('app', 'commands')))

load_dotenv()

from config import Config

app = Flask(__name__)
app.config.from_object(Config)

url_shortener = Shortener(tokens=[app.config['BITLY_API_TOKEN']],
                          max_cache_size=256)

db = SQLAlchemy(app)
migrate = Migrate(app, db)

from app._vk import VkAPI_
vk = VkAPI_(app_token=app.config['VK_APP_SERVICE_KEY'],
            app_id=app.config['VK_APP_ID'],
            group_token=app.config['VK_COMMUNITY_TOKEN'],
            client_secret=app.config['VK_APP_CLIENT_SECRET'])

from app import models
示例#16
0
from webapp.user import User

import webapp.config as config

from flask_login import current_user, LoginManager

from webapp.mockdbhelper import MockDBHelper as DBHelper

from webapp.forms import CreateTableForm

from bitlyshortener import Shortener

tokens_pool = ['my_access_token']  # Use your own.
print(os.getpid(), threading.get_ident())
shortener = Shortener(tokens=tokens_pool, max_cache_size=128)

app = Flask(__name__)
login_manager = LoginManager(app)
app.secret_key = "Gxf613UhGRkzAKd47R5daLrUelnlUL4L6AU4z0uu++TNBpdzhAolufHqPQiiEdn34pbE97bmXbN"

DB = DBHelper()


# load the user
@login_manager.user_loader
def load_user(user_id):
    user_password = DB.get_user(user_id)
    if user_password:
        return User(user_id)
示例#17
0
# Requires python > 3.7
# pip3 install bitlyshortener
# Requires a bitly account and oauth key

import sys
import os.path
from bitlyshortener import Shortener
token = ['<YOUR TOKEN HERE>']
shortener = Shortener(tokens=token, max_cache_size=8192)
urlDict = {}


def shorten_single_url():
    url = input('\nEnter a url to shorten: ')
    urlDict[url] = shortener._shorten_url(url)

    for key in urlDict:
        print("\n{} : {}".format(key, urlDict[key]))

    to_file()


def shorten_url_list():
    urls = input('\nEnter a text file of urls to shorten: ')
    print()
    if os.path.isfile(urls):
        with open(urls, 'r') as f:
            for line in (f.readlines()):
                urlDict[line] = shortener._shorten_url(line)
            for key in urlDict:
                print("{} : {}".format(key.strip(), urlDict[key]))
示例#18
0
    def url(
        self,
        asin_or_url: str,
        affiliate_tag: Optional[str] = None,
        shorten_url: Optional[bool] = None,
        accept_long_url: Optional[bool] = None,
        bitly_token: Optional[Tuple[str, List[str]]] = None,
        country: Optional[Union[Country, str]] = None
    ) -> Optional[str]:
        """Generate affiliate url, or replace ones tag with yours

        Args:
            asin_or_url (str): An asin or an amazon url
            affiliate_tag (Optional[str], optional): [description]. Defaults to None(used from self).
            shorten_url (Optional[bool], optional): Shorten the generated url. Defaults to None(used from self(defults to False)).
            accept_long_url (Optional[bool], optional): If url shortening is unsuccessful, should the url still be returned. Defaults to None(used from self(defults to True)).
            bitly_token (Optional[Tuple[str, List[str]]], optional): Bitly token(s) needed for URL shortening. Defaults to None.
            country (Optional[Country], optional): Country to use to create the link with. Only used, if asin is passed instead of url (Defaults to None --> Country.UnitedStates).

        Returns:
            Optional[str]: Amazon url with the passed affiliate tag
        """
        if 'amazon.' in asin_or_url or 'amzn.' in asin_or_url:
            url = asin_or_url

            if not asin_or_url.startswith('https://') and not asin_or_url.startswith('http://'):
                url = 'https://{}'.format(url)
        else:
            country = country or self.country or Country.UnitedStates

            if isinstance(country, Country):
                country = country.value

            url = 'https://amazon.{}/dp/{}'.format(country, asin_or_url)

        parsed_url = urlparse(url)

        if not parsed_url.netloc:
            print('ERROR-AmazonAffiliateUrl: Invalid Formatted URL Original:\'{}\' ---> Formatted:\'{}\''.format(asin_or_url, url))

            return None

        affiliate_tag = affiliate_tag or self.affiliate_tag

        if not affiliate_tag.endswith('-20'):
            affiliate_tag += '-20'

        shorten_url = shorten_url if shorten_url is not None else self.shorten_urls

        query_dict = parse_qs(parsed_url[4])
        query_dict['tag'] = affiliate_tag or self.affiliate_tag
        parsed_url = parsed_url[:4] + (urlencode(query_dict, True), ) + parsed_url[5:]
        url = urlunparse(parsed_url)

        if shorten_url:
            bitly_token = bitly_token or self.bitly_token
            accept_long_url = accept_long_url if accept_long_url is not None else self.accept_long_urls

            if not bitly_token:
                print('WARNING-AmazonAffiliateUrl: No bitly token(s) passed. These are necessary for URL shortening.')

                return url if accept_long_url else None

            if type(bitly_token) == str:
                bitly_token = [bitly_token]

            short_urls = Shortener(tokens=bitly_token).shorten_urls([url])

            if short_urls:
                return short_urls[0]
            elif accept_long_url:
                return url

            return None

        return url
示例#19
0
"""Print the used percentage."""
import os
import time

from bitlyshortener import Shortener, config  # pylint: disable=import-error

config.configure_logging()

# pylint: disable=invalid-name
TOKENS = os.environ["BITLY_TOKENS"].strip().split(",")
print(f"Number of tokens is {len(TOKENS)}.")

try:
    shortener = Shortener(tokens=TOKENS)
    usage = shortener.usage()
    print(f"Used percentage is {usage:.1%}.")
except Exception:
    time.sleep(0.01)  # Delay for longs to flush.
    raise
示例#20
0
import json
import os

from bitlyshortener import Shortener
from retrying import retry

SHORTENER = Shortener(tokens=[os.getenv("BITLY_GENERIC_ACCESS_TOKEN")],
                      max_cache_size=8192)


@retry(stop_max_attempt_number=5, wait_fixed=30000)
def retryable_shorten(url):
    return dict(id=SHORTENER.shorten_urls([url])[0])


def handler(event, context):
    shortened = retryable_shorten(event['queryStringParameters']['url'])
    result = dict(statusCode=200, body=json.dumps(shortened))
    return result