Description bad argument url error badargument

Содержание

1. Ошибка при загрузке изображения с библиотекой запросов
2. Ошибка разбора BadArgument и JSON при вызове API
3. discord.ext.commands.errors.BadArgument: Expected space after closing quotation #1865
4. Comments
5. Name already in use
6. api / docs_eng / errors.md

I have a problem while using the sample view «Biblio OAI-PMH» in an HTTP GET request :

Have you an explanation ?

Thanks in advance

Я пытаюсь внедрить в свой код переводчик Yandex OCR. С помощью Burp Suite мне удалось обнаружить, что для отправки изображения используется следующий запрос:

Я пытаюсь эмулировать этот запрос с помощью следующего кода:

import requests
from requests_toolbelt import MultipartEncoder
files={
    'file':("blob",open("image_path", 'rb'),"image/jpeg")
    }

#(<filename>, <file object>, <content type>, <per-part headers>)
burp0_url = "https://translate.yandex.net:443/ocr/v1.1/recognize?srv=tr-image&sid=9b58493f.5c781bd4.7215c0a0&lang=en%2Cru"


m = MultipartEncoder(files, boundary='-----------------------------7652580604126525371226493196')

burp0_headers = {"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:65.0) Gecko/20100101 Firefox/65.0", "Accept": "*/*", "Accept-Language": "en-US,en;q=0.5", "Accept-Encoding": "gzip, deflate", "Referer": "https://translate.yandex.com/", "Content-Type": "multipart/form-data; boundary=-----------------------------7652580604126525371226493196", "Origin": "https://translate.yandex.com", "DNT": "1", "Connection": "close"}

print(requests.post(burp0_url, headers=burp0_headers, files=m.to_string()).text)

Хотя, к сожалению, это дает следующий вывод:

{"error":"BadArgument","description":"Bad argument: file"}

Кто-нибудь знает, как это можно решить?

Спасибо заранее!

Вы передаете результат MultipartEncoder.to_string() параметру files. Теперь вы запрашиваете запросы на кодирование результата многокомпонентного кодера в многокомпонентный компонент. Это один раз слишком много.

Вам не нужно реплицировать каждый байт здесь, просто опубликуйте файл и возможно установите агент пользователя, реферер и источник:

files = {
    'file': ("blob", open("image_path", 'rb'), "image/jpeg")
}

url = "https://translate.yandex.net:443/ocr/v1.1/recognize?srv=tr-image&sid=9b58493f.5c781bd4.7215c0a0&lang=en%2Cru"
headers = {
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:65.0) Gecko/20100101 Firefox/65.0", 
    "Referer": "https://translate.yandex.com/",
    "Origin": "https://translate.yandex.com",
}

response = requests.post(url, headers=headers, files=files)
print(response.status)
print(response.json())

Заголовок Connection лучше оставить для запросов, он может контролировать, когда соединение должно поддерживаться в рабочем состоянии. Заголовки Accept * предназначены для того, чтобы сообщить серверу, что может обработать ваш клиент, и requests также устанавливает их автоматически.

Я получаю 200 OK ответ с этим кодом:

200
{'data': {'blocks': []}, 'status': 'success'}

Однако если вы не установите дополнительные заголовки (удалите аргумент headers=headers), запрос также сработает, поэтому, похоже, Яндекс здесь не фильтрует роботов.

def retrieve_emoji(self) -> typing.Tuple[str, str]:

        sent_emoji = self.config["sent_emoji"]
        blocked_emoji = self.config["blocked_emoji"]

        if sent_emoji != "disable":
            try:
                sent_emoji = await self.convert_emoji(sent_emoji)
            except commands.BadArgument:
                logger.warning("Removed sent emoji (%s).", sent_emoji)
                sent_emoji = self.config.remove("sent_emoji")
                await self.config.update()

        if blocked_emoji != "disable":
            try:
                blocked_emoji = await self.convert_emoji(blocked_emoji)
            except commands.BadArgument:
                logger.warning("Removed blocked emoji (%s).", blocked_emoji)
                blocked_emoji = self.config.remove("blocked_emoji")
                await self.config.update()

        return sent_emoji, blocked_emoji 

def allowed_strings(*values, preserve_case: bool = False) -> t.Callable[[str], str]:
    """
    Return a converter which only allows arguments equal to one of the given values.

    Unless preserve_case is True, the argument is converted to lowercase. All values are then
    expected to have already been given in lowercase too.
    """
    def converter(arg: str) -> str:
        if not preserve_case:
            arg = arg.lower()

        if arg not in values:
            raise BadArgument(f"Only the following values are allowed:n```{', '.join(values)}```")
        else:
            return arg

    return converter 

def convert(ctx: Context, url: str) -> str:
        """This converter checks whether the given URL can be reached with a status code of 200."""
        try:
            async with ctx.bot.http_session.get(url) as resp:
                if resp.status != 200:
                    raise BadArgument(
                        f"HTTP GET on `{url}` returned status `{resp.status}`, expected 200"
                    )
        except CertificateError:
            if url.startswith('https'):
                raise BadArgument(
                    f"Got a `CertificateError` for URL `{url}`. Does it support HTTPS?"
                )
            raise BadArgument(f"Got a `CertificateError` for URL `{url}`.")
        except ValueError:
            raise BadArgument(f"`{url}` doesn't look like a valid hostname to me.")
        except ClientConnectorError:
            raise BadArgument(f"Cannot connect to host with URL `{url}`.")
        return url 

def convert(ctx: Context, sub: str) -> str:
        """
        Force sub to begin with "r/" and check if it's a valid subreddit.

        If sub is a valid subreddit, return it prepended with "r/"
        """
        sub = sub.lower()

        if not sub.startswith("r/"):
            sub = f"r/{sub}"

        resp = await ctx.bot.http_session.get(
            "https://www.reddit.com/subreddits/search.json",
            params={"q": sub}
        )

        json = await resp.json()
        if not json["data"]["children"]:
            raise BadArgument(
                f"The subreddit `{sub}` either doesn't exist, or it has no posts."
            )

        return sub 

def convert(ctx: Context, tag_name: str) -> str:
        """Lowercase & strip whitespace from proposed tag_name & ensure it's valid."""
        tag_name = tag_name.lower().strip()

        # The tag name has at least one invalid character.
        if ascii(tag_name)[1:-1] != tag_name:
            raise BadArgument("Don't be ridiculous, you can't use that character!")

        # The tag name is either empty, or consists of nothing but whitespace.
        elif not tag_name:
            raise BadArgument("Tag names should not be empty, or filled with whitespace.")

        # The tag name is longer than 127 characters.
        elif len(tag_name) > 127:
            raise BadArgument("Are you insane? That's way too long!")

        # The tag name is ascii but does not contain any letters.
        elif not any(character.isalpha() for character in tag_name):
            raise BadArgument("Tag names must contain at least one letter.")

        return tag_name 

def convert(self, ctx: Context, argument: str) -> t.Optional[int]:
        """
        Convert `argument` to a duration that's max 15 minutes or None.

        If `"forever"` is passed, None is returned; otherwise an int of the extracted time.
        Accepted formats are:
        * <duration>,
        * <duration>m,
        * <duration>M,
        * forever.
        """
        if argument == "forever":
            return None
        match = self.MINUTES_RE.match(argument)
        if not match:
            raise BadArgument(f"{argument} is not a valid minutes duration.")

        duration = int(match.group(1))
        if duration > 15:
            raise BadArgument("Duration must be at most 15 minutes.")
        return duration 

def convert(self, ctx: Context, arg: str) -> t.Union[discord.User, discord.Object]:
        """Convert the `arg` to a `discord.User` or `discord.Object`."""
        try:
            return await super().convert(ctx, arg)
        except BadArgument:
            pass

        try:
            user_id = int(arg)
            log.trace(f"Fetching user {user_id}...")
            return await ctx.bot.fetch_user(user_id)
        except ValueError:
            log.debug(f"Failed to fetch user {arg}: could not convert to int.")
            raise BadArgument(f"The provided argument can't be turned into integer: `{arg}`")
        except discord.HTTPException as e:
            # If the Discord error isn't `Unknown user`, return a proxy instead
            if e.code != 10013:
                log.info(f"Failed to fetch user, returning a proxy instead: status {e.status}")
                return proxy_user(arg)

            log.debug(f"Failed to fetch user {arg}: user does not exist.")
            raise BadArgument(f"User `{arg}` does not exist") 

def on_command_error(ctx, error):

    send_help = (commands.MissingRequiredArgument, commands.BadArgument, commands.TooManyArguments, commands.UserInputError)

    if isinstance(error, commands.CommandNotFound):  # fails silently
        pass

    elif isinstance(error, send_help):
        _help = await send_cmd_help(ctx)
        await ctx.send(embed=_help)

    elif isinstance(error, commands.CommandOnCooldown):
        await ctx.send(f'This command is on cooldown. Please wait {error.retry_after:.2f}s')

    elif isinstance(error, commands.MissingPermissions):
        await ctx.send('You do not have the permissions to use this command.')
    # If any other error occurs, prints to console.
    else:
        print(''.join(traceback.format_exception(type(error), error, error.__traceback__))) 

def convert(self, ctx, argument):
		message = await commands.converter.MessageConverter().convert(ctx, argument)

		if message.channel not in ctx.bot.cogs['Logger'].channels:
			raise commands.BadArgument(_('That message is not from a log channel.'))

		try:
			embed = message.embeds[0]
		except IndexError:
			raise commands.BadArgument(_('No embeds were found in that message.'))

		m = re.match(LINKED_EMOTE, embed.description) or re.match(utils.lexer.t_CUSTOM_EMOTE, embed.description)
		try:
			return await ctx.bot.cogs['Database'].get_emote(m['name'])
		except EmoteNotFoundError:
			d = m.groupdict()
			d['nsfw'] = 'MOD_NSFW'
			d['id'] = int(d['id'])
			d['animated'] = d.get('extension') == 'gif' or bool(d.get('animated'))
			return DatabaseEmote(d)

# because MultiConverter does not support Union 

def convert(self, ctx, argument):
		err = None
		try:
			logged_emote = await LoggedEmote().convert(ctx, argument)
		except commands.CommandError as exc:
			pass
		else:
			return logged_emote

		try:
			db_emote = await self.db_conv.convert(ctx, argument)
		except commands.CommandError as exc:
			raise commands.BadArgument(
				_('Failed to interpret {argument} as a logged emote message or an emote in my database.')
				.format(argument=argument))

		return db_emote 

def command_error(self, ctx: Context, error: CommandError) -> None:
        """Local error handler for the Snake Cog."""
        embed = Embed()
        embed.colour = Colour.red()

        if isinstance(error, BadArgument):
            embed.description = str(error)
            embed.title = random.choice(ERROR_REPLIES)

        elif isinstance(error, OSError):
            log.error(f"snake_card encountered an OSError: {error} ({error.original})")
            embed.description = "Could not generate the snake card! Please try again."
            embed.title = random.choice(ERROR_REPLIES)

        else:
            log.error(f"Unhandled tag command error: {error} ({error.original})")
            return

        await ctx.send(embed=embed)
    # endregion 

def convert(self, ctx: commands.Context, coordinate: str) -> typing.Tuple[int, int]:
        """Take in a coordinate string and turn it into an (x, y) tuple."""
        if not 2 <= len(coordinate) <= 3:
            raise commands.BadArgument('Invalid co-ordinate provided')

        coordinate = coordinate.lower()
        if coordinate[0].isalpha():
            digit = coordinate[1:]
            letter = coordinate[0]
        else:
            digit = coordinate[:-1]
            letter = coordinate[-1]

        if not digit.isdigit():
            raise commands.BadArgument

        x = ord(letter) - ord('a')
        y = int(digit) - 1

        if (not 0 <= x <= 9) or (not 0 <= y <= 9):
            raise commands.BadArgument
        return x, y 

def dj(self, ctx, *, role):
        settings = await SettingsDB.get_instance().get_guild_settings(ctx.guild.id)
        if role.lower() == "none":
            settings.djroleId = "NONE"
            await SettingsDB.get_instance().set_guild_settings(settings)
            await ctx.send(f"{SUCCESS} The DJ role has been cleared, only people with the manage server permission "
                           f"can use DJ commands now")
        else:
            try:
                role = await commands.RoleConverter().convert(ctx, role)
            except commands.BadArgument:
                await ctx.send(f"{WARNING} That role was not found!")
                return
            settings.djroleId = role.id
            await SettingsDB.get_instance().set_guild_settings(settings)
            await ctx.send(f"{SUCCESS} DJ commands can now only be used by people who have the **{role.name}** role "
                           f"or the manage server permission") 

def tc(self, ctx, *, channel):
        settings = await SettingsDB.get_instance().get_guild_settings(ctx.guild.id)
        if channel.lower() == "none":
            settings.textId = "NONE"
            await SettingsDB.get_instance().set_guild_settings(settings)
            await ctx.send(f"{SUCCESS} The music text channel has been cleared, people can now use music commands in "
                           f"all text channels")
        else:
            try:
                channel = await commands.TextChannelConverter().convert(ctx, channel)
            except commands.BadArgument:
                await ctx.send(f"{WARNING} That channel was not found!")
                return
            settings.textId = channel.id
            await SettingsDB.get_instance().set_guild_settings(settings)
            await ctx.send(f"{SUCCESS} Music commands can now only be used in the **{channel.name}** text channel") 

def vc(self, ctx, *, channel):
        settings = await SettingsDB.get_instance().get_guild_settings(ctx.guild.id)
        if channel.lower() == "none":
            settings.voiceId = "NONE"
            await SettingsDB.get_instance().set_guild_settings(settings)
            await ctx.send(f"{SUCCESS} The music voice channel has been cleared, people can now play music in all "
                           f"channels")
        else:
            try:
                channel = await commands.VoiceChannelConverter().convert(ctx, channel)
            except commands.BadArgument:
                await ctx.send(f"{WARNING} That channel was not found!")
                return
            settings.voiceId = channel.id
            await SettingsDB.get_instance().set_guild_settings(settings)
            await ctx.send(f"{SUCCESS} Music can now only be played in the **{channel.name}** voice channel") 

def on_command_error(self, ctx, exception):
        exc_class = exception.__class__
        if exc_class in (commands.CommandNotFound, commands.NotOwner):
            return

        exc_table = {
            commands.MissingRequiredArgument: f"{WARNING} The required arguments are missing for this command!",
            commands.NoPrivateMessage: f"{WARNING} This command cannot be used in PM's!",
            commands.BadArgument: f"{WARNING} A bad argument was passed, please check if your arguments are correct!",
            IllegalAction: f"{WARNING} A node error has occurred: `{getattr(exception, 'msg', None)}`",
            CustomCheckFailure: getattr(exception, "msg", None) or "None"
        }

        if exc_class in exc_table.keys():
            await ctx.send(exc_table[exc_class])
        else:
            await super().on_command_error(ctx, exception) 

def test_tag_content_converter_for_invalid(self):
        """TagContentConverter should raise the proper exception for invalid input."""
        test_values = (
            ('', "Tag contents should not be empty, or filled with whitespace."),
            ('   ', "Tag contents should not be empty, or filled with whitespace."),
        )

        for value, exception_message in test_values:
            with self.subTest(tag_content=value, exception_message=exception_message):
                with self.assertRaisesRegex(BadArgument, re.escape(exception_message)):
                    await TagContentConverter.convert(self.context, value) 

def test_valid_python_identifier_for_invalid(self):
        """ValidPythonIdentifier raises the proper exception for invalid identifiers."""
        test_values = ('nested.stuff', '#####')

        for name in test_values:
            with self.subTest(identifier=name):
                exception_message = f'`{name}` is not a valid Python identifier'
                with self.assertRaisesRegex(BadArgument, re.escape(exception_message)):
                    await ValidPythonIdentifier.convert(self.context, name) 

def test_duration_converter_for_invalid(self):
        """Duration raises the right exception for invalid duration strings."""
        test_values = (
            # Units in wrong order
            '1d1w',
            '1s1y',

            # Duplicated units
            '1 year 2 years',
            '1 M 10 minutes',

            # Unknown substrings
            '1MVes',
            '1y3breads',

            # Missing amount
            'ym',

            # Incorrect whitespace
            " 1y",
            "1S ",
            "1y  1m",

            # Garbage
            'Guido van Rossum',
            'lemon lemon lemon lemon lemon lemon lemon',
        )

        converter = Duration()

        for invalid_duration in test_values:
            with self.subTest(invalid_duration=invalid_duration):
                exception_message = f'`{invalid_duration}` is not a valid duration string.'
                with self.assertRaisesRegex(BadArgument, re.escape(exception_message)):
                    await converter.convert(self.context, invalid_duration) 

def test_duration_converter_out_of_range(self, mock_datetime):
        """Duration converter should raise BadArgument if datetime raises a ValueError."""
        mock_datetime.__add__.side_effect = ValueError
        mock_datetime.utcnow.return_value = mock_datetime

        duration = f"{datetime.MAXYEAR}y"
        exception_message = f"`{duration}` results in a datetime outside the supported range."
        with self.assertRaisesRegex(BadArgument, re.escape(exception_message)):
            await Duration().convert(self.context, duration) 

def test_hush_duration_converter_for_invalid(self):
        """HushDurationConverter raises correct exception for invalid minutes duration strings."""
        test_values = (
            ("16", "Duration must be at most 15 minutes."),
            ("10d", "10d is not a valid minutes duration."),
            ("-1", "-1 is not a valid minutes duration."),
        )
        converter = HushDurationConverter()
        for invalid_minutes_string, exception_message in test_values:
            with self.subTest(invalid_minutes_string=invalid_minutes_string, exception_message=exception_message):
                with self.assertRaisesRegex(BadArgument, re.escape(exception_message)):
                    await converter.convert(self.context, invalid_minutes_string) 

def convert(self, ctx: Context, argument: str) -> str:
        """Fully qualify the name of an extension and ensure it exists."""
        # Special values to reload all extensions
        if argument == "*" or argument == "**":
            return argument

        argument = argument.lower()

        if "." not in argument:
            argument = f"bot.cogs.{argument}"

        if argument in EXTENSIONS:
            return argument
        else:
            raise commands.BadArgument(f":x: Could not find the extension `{argument}`.") 

def cog_command_error(self, ctx: Context, error: Exception) -> None:
        """Handle BadArgument errors locally to prevent the help command from showing."""
        if isinstance(error, commands.BadArgument):
            await ctx.send(str(error))
            error.handled = True 

def convert(ctx: Context, argument: str) -> str:
        """Checks whether the given string is a valid Python identifier."""
        if not argument.isidentifier():
            raise BadArgument(f"`{argument}` is not a valid Python identifier")
        return argument 

def convert(self, ctx: Context, duration: str) -> datetime:
        """
        Converts a `duration` string to a datetime object that's `duration` in the future.

        The converter supports the following symbols for each unit of time:
        - years: `Y`, `y`, `year`, `years`
        - months: `m`, `month`, `months`
        - weeks: `w`, `W`, `week`, `weeks`
        - days: `d`, `D`, `day`, `days`
        - hours: `H`, `h`, `hour`, `hours`
        - minutes: `M`, `minute`, `minutes`
        - seconds: `S`, `s`, `second`, `seconds`

        The units need to be provided in descending order of magnitude.
        """
        match = self.duration_parser.fullmatch(duration)
        if not match:
            raise BadArgument(f"`{duration}` is not a valid duration string.")

        duration_dict = {unit: int(amount) for unit, amount in match.groupdict(default=0).items()}
        delta = relativedelta(**duration_dict)
        now = datetime.utcnow()

        try:
            return now + delta
        except ValueError:
            raise BadArgument(f"`{duration}` results in a datetime outside the supported range.") 

def convert(self, ctx: Context, datetime_string: str) -> datetime:
        """
        Converts a ISO-8601 `datetime_string` into a `datetime.datetime` object.

        The converter is flexible in the formats it accepts, as it uses the `isoparse` method of
        `dateutil.parser`. In general, it accepts datetime strings that start with a date,
        optionally followed by a time. Specifying a timezone offset in the datetime string is
        supported, but the `datetime` object will be converted to UTC and will be returned without
        `tzinfo` as a timezone-unaware `datetime` object.

        See: https://dateutil.readthedocs.io/en/stable/parser.html#dateutil.parser.isoparse

        Formats that are guaranteed to be valid by our tests are:

        - `YYYY-mm-ddTHH:MM:SSZ` | `YYYY-mm-dd HH:MM:SSZ`
        - `YYYY-mm-ddTHH:MM:SS±HH:MM` | `YYYY-mm-dd HH:MM:SS±HH:MM`
        - `YYYY-mm-ddTHH:MM:SS±HHMM` | `YYYY-mm-dd HH:MM:SS±HHMM`
        - `YYYY-mm-ddTHH:MM:SS±HH` | `YYYY-mm-dd HH:MM:SS±HH`
        - `YYYY-mm-ddTHH:MM:SS` | `YYYY-mm-dd HH:MM:SS`
        - `YYYY-mm-ddTHH:MM` | `YYYY-mm-dd HH:MM`
        - `YYYY-mm-dd`
        - `YYYY-mm`
        - `YYYY`

        Note: ISO-8601 specifies a `T` as the separator between the date and the time part of the
        datetime string. The converter accepts both a `T` and a single space character.
        """
        try:
            dt = dateutil.parser.isoparse(datetime_string)
        except ValueError:
            raise BadArgument(f"`{datetime_string}` is not a valid ISO-8601 datetime string")

        if dt.tzinfo:
            dt = dt.astimezone(dateutil.tz.UTC)
            dt = dt.replace(tzinfo=None)

        return dt 

def proxy_user(user_id: str) -> discord.Object:
    """
    Create a proxy user object from the given id.

    Used when a Member or User object cannot be resolved.
    """
    log.trace(f"Attempting to create a proxy user for the user id {user_id}.")

    try:
        user_id = int(user_id)
    except ValueError:
        log.debug(f"Failed to create proxy user {user_id}: could not convert to int.")
        raise BadArgument(f"User ID `{user_id}` is invalid - could not convert to an integer.")

    user = discord.Object(user_id)
    user.mention = user.id
    user.display_name = f"<@{user.id}>"
    user.avatar_url_as = lambda static_format: None
    user.bot = False

    return user 

def convert(self, ctx, argument):
        argument = argument.replace(",", "").strip("$")
        if not argument.strip("-").replace(".", "").isdigit():
            raise commands.BadArgument("That is not a number!")
        if len(argument) > 10:
            raise commands.BadArgument("That number is much too big! Must be less than 999,999,999")
        return round(float(argument), 2) 

def convert(self, ctx, argument):
        argument = argument.replace(",", "").strip("$")
        if not argument.strip("-").replace(".", "").isdigit():
            raise commands.BadArgument("That is not a number!")
        if len(argument) > 10:
            raise commands.BadArgument("That number is much too big! Must be less than 999,999,999")
        return int(argument) 

def convert(self, ctx, argument):
        fargument = argument.replace(",", "").strip("$")
        if not fargument.strip("-").replace(".", "").isdigit():
            if "x" in argument:
                item, n = argument.split("x")
                if n.isdigit():
                    return item, int(n)
            return argument
        if len(fargument) > 10:
            raise commands.BadArgument("That number is much too big! Must be less than 999,999,999")
        return round(float(fargument), 2)