fifa-panini 1.0.0__tar.gz

fifa_panini-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Filipe Pina
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fifa_panini-1.0.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: fifa-panini
+Version: 1.0.0
+Summary: CLI for trying FIFA Panini promo codes against an endpoint
+Author-email: Filipe Pina <shelf-corncob-said@duck.com>
+Project-URL: Homepage, https://github.com/fopina/fifa-panini-pack-finder
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: classyclick>=1.0.3
+Requires-Dist: requests>=2.33.0
+Requires-Dist: tqdm>=4.67.1
+Dynamic: license-file
+
+# fifa-panini
+
+CLI for trying FIFA Panini promo codes against the API.
+
+## Install
+
+```
+pip install fifa-panini
+```
+
+## Usage
+
+```
+$ fifa-panini panini --cookie 'session=value; other=value' try-code --dry-run VD13-V24K-ABCD
+DRY RUN POST https://paninicollection.fifa.com/api/unlock_pack.json code=VD13-V24K-ABCD
+```
+
+Brute-force the final block from a known-used code base:
+
+```
+$ fifa-panini panini --cookie 'session=value; other=value' bf-code --dry-run --code-base VD13-V24K-0000
+DRY RUN POST https://paninicollection.fifa.com/api/unlock_pack.json code=VD13-V24K-AAAA
+```
+
+Claim the current daily Panini packs:
+
+```
+$ fifa-panini panini --cookie 'session=value; other=value' claim
+```
+
+Fetch the daily promo code from FIFA Play:
+
+```
+$ fifa-panini daily-play --cookie 'session=value; other=value'
+```
+
+Persist settings in the classyclick config file:
+
+```
+$ fifa-panini config -e
+$ fifa-panini panini bf-code --dry-run
+```
+
+```python
+>>> from fifa_panini.commands.bf_code import BfCode
+>>> BfCode(code_base='VD13-V24K-0000').next_code()
+'VD13-V24K-AAAA'
+```
+
+## Build
+
+Check out [CONTRIBUTING.md](CONTRIBUTING.md)

fifa_panini-1.0.0/README.md

@@ -0,0 +1,52 @@
+# fifa-panini
+
+CLI for trying FIFA Panini promo codes against the API.
+
+## Install
+
+```
+pip install fifa-panini
+```
+
+## Usage
+
+```
+$ fifa-panini panini --cookie 'session=value; other=value' try-code --dry-run VD13-V24K-ABCD
+DRY RUN POST https://paninicollection.fifa.com/api/unlock_pack.json code=VD13-V24K-ABCD
+```
+
+Brute-force the final block from a known-used code base:
+
+```
+$ fifa-panini panini --cookie 'session=value; other=value' bf-code --dry-run --code-base VD13-V24K-0000
+DRY RUN POST https://paninicollection.fifa.com/api/unlock_pack.json code=VD13-V24K-AAAA
+```
+
+Claim the current daily Panini packs:
+
+```
+$ fifa-panini panini --cookie 'session=value; other=value' claim
+```
+
+Fetch the daily promo code from FIFA Play:
+
+```
+$ fifa-panini daily-play --cookie 'session=value; other=value'
+```
+
+Persist settings in the classyclick config file:
+
+```
+$ fifa-panini config -e
+$ fifa-panini panini bf-code --dry-run
+```
+
+```python
+>>> from fifa_panini.commands.bf_code import BfCode
+>>> BfCode(code_base='VD13-V24K-0000').next_code()
+'VD13-V24K-AAAA'
+```
+
+## Build
+
+Check out [CONTRIBUTING.md](CONTRIBUTING.md)

fifa_panini-1.0.0/fifa_panini/__init__.py

@@ -0,0 +1,19 @@
+import re
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '1.0.0'
+__version_tuple__ = version_tuple = tuple(
+    int(part) if part.isdigit() else part for part in re.split(r'\.|(?<=[0-9])(?=[a-zA-Z])', version)
+)

fifa_panini-1.0.0/fifa_panini/__main__.py

@@ -0,0 +1,9 @@
+from .cli import CLI
+
+
+def main():
+    CLI.click()
+
+
+if __name__ == '__main__':
+    main()

fifa_panini-1.0.0/fifa_panini/cli.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+import classyclick
+import classyclick.helpers
+import click
+
+from . import __version__
+
+CONFIG_EXAMPLE_PATH = Path(__file__).with_name('config.example.toml')
+
+
+class CLI(classyclick.helpers.ConfigFileMixin, classyclick.Group):
+    """Tools for testing FIFA Panini promo codes."""
+
+    __config__ = classyclick.Group.Config(
+        name='fifa-panini',
+        decorators=[click.version_option(version=__version__)],
+    )
+    CONFIG_DEFAULT_NAME = 'fifa-panini'
+    CONFIG_EXAMPLE_PATH = CONFIG_EXAMPLE_PATH
+
+    def __call__(self):
+        self.load_config()
+
+
+classyclick.helpers.discover_commands(f'{__package__}.commands')

fifa_panini-1.0.0/fifa_panini/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command modules discovered by classyclick."""

fifa_panini-1.0.0/fifa_panini/commands/config.py

@@ -0,0 +1,9 @@
+from classyclick.helpers.config import ConfigBaseCommand
+
+from ..cli import CLI
+
+
+class Config(ConfigBaseCommand, CLI.Command):
+    """Show or edit the current CLI configuration."""
+
+    MASKED_FIELDS = ('cookie',)

fifa_panini-1.0.0/fifa_panini/commands/daily_play.py

@@ -0,0 +1,128 @@
+import json
+from urllib.request import Request, urlopen
+
+import classyclick
+import click
+
+from ..cli import CLI
+from ..utils.codes import CodeResponse
+from ..utils.panini import validate_cookie_header
+
+DEFAULT_DAILY_PLAY_ENDPOINT = 'https://play.fifa.com/api/en/gamezone/panini/code'
+DEFAULT_REQUEST_TIMEOUT = 30.0
+
+
+class DailyPlay(CLI.Command):
+    """Fetch the current FIFA Play daily promo code."""
+
+    cookie: str = classyclick.Option(
+        '-c',
+        '--cookie',
+        help='Complete Cookie header value copied from the daily Play code browser request.',
+    )
+
+    def __call__(self):
+        self.validate_settings()
+
+        response = self.send_code()
+        payload = self.response_payload(response)
+        if self.code_generation_is_pending(payload):
+            response = self.send_code(method='POST')
+            payload = self.response_payload(response)
+
+        self.print_payload(payload)
+
+    def validate_settings(self):
+        if not self.cookie:
+            raise click.ClickException(
+                'Missing required setting(s): cookie. Pass them as options or save them in the config file.'
+            )
+        validate_cookie_header(self.cookie)
+
+    def print_response(self, response):
+        self.print_payload(self.response_payload(response))
+
+    @staticmethod
+    def response_payload(response):
+        try:
+            payload = json.loads(response.text)
+        except json.JSONDecodeError as error:
+            raise click.ClickException(f'Response was not valid JSON: {error}') from error
+
+        if not isinstance(payload, dict):
+            raise click.ClickException('Response JSON must be an object.')
+
+        return payload
+
+    def print_payload(self, payload):
+        errors = payload.get('errors')
+        if errors:
+            raise click.ClickException(f'Response errors: {self.format_errors(errors)}')
+
+        code = self.daily_code(payload)
+        if not code:
+            raise click.ClickException('Response did not include a daily promo code.')
+
+        click.echo(code)
+
+    @staticmethod
+    def code_generation_is_pending(payload):
+        success = payload.get('success')
+        if not isinstance(success, dict):
+            return False
+
+        panini_code = success.get('paniniCode')
+        if not isinstance(panini_code, dict):
+            return False
+
+        return 'code' in panini_code and panini_code.get('code') is None
+
+    @staticmethod
+    def daily_code(payload):
+        success = payload.get('success')
+        if not isinstance(success, dict):
+            return None
+
+        panini_code = success.get('paniniCode')
+        if not isinstance(panini_code, dict):
+            return None
+
+        code = panini_code.get('code')
+        if not isinstance(code, str):
+            return None
+
+        code = code.strip()
+        return code or None
+
+    @staticmethod
+    def format_errors(errors):
+        if isinstance(errors, list):
+            return ', '.join(DailyPlay.format_error(error) for error in errors)
+        return DailyPlay.format_error(errors)
+
+    @staticmethod
+    def format_error(error):
+        if isinstance(error, str):
+            return error
+        return json.dumps(error, separators=(',', ':'))
+
+    def send_code(self, method='GET'):
+        request = Request(
+            DEFAULT_DAILY_PLAY_ENDPOINT,
+            headers={
+                'Cookie': self.cookie,
+                'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:152.0) Gecko/20100101 Firefox/152.0',
+                'Accept': '*/*',
+                'Accept-Language': 'en-GB,en;q=0.9',
+            },
+            method=method,
+        )
+
+        try:
+            with urlopen(request, timeout=DEFAULT_REQUEST_TIMEOUT) as response:
+                return CodeResponse(
+                    text=response.read().decode('utf-8', errors='replace'),
+                    headers=dict(response.headers.items()),
+                )
+        except OSError as error:
+            raise click.ClickException(f'Request failed for {DEFAULT_DAILY_PLAY_ENDPOINT}: {error}') from error

fifa_panini-1.0.0/fifa_panini/commands/panini/__init__.py

@@ -0,0 +1,36 @@
+import classyclick
+
+from ...cli import CLI
+from ...utils.panini import (
+    API_ENDPOINT,
+    PANINI_API_ENDPOINT_META_KEY,
+    PANINI_COOKIE_META_KEY,
+)
+
+__all__ = [
+    'API_ENDPOINT',
+    'PANINI_API_ENDPOINT_META_KEY',
+    'PANINI_COOKIE_META_KEY',
+    'Panini',
+]
+
+
+class Panini(CLI.SubGroup):
+    """Try and brute-force FIFA Panini promo codes."""
+
+    cookie: str = classyclick.Option(
+        '-c',
+        '--cookie',
+        help='Complete Cookie header value copied from the browser request.',
+    )
+    api_endpoint: str = classyclick.Option(
+        '--api-endpoint',
+        default=API_ENDPOINT,
+        show_default=True,
+        help='Panini API base URL.',
+    )
+    ctx: classyclick.Context = classyclick.Context()
+
+    def __call__(self):
+        self.ctx.meta[PANINI_COOKIE_META_KEY] = self.cookie
+        self.ctx.meta[PANINI_API_ENDPOINT_META_KEY] = self.api_endpoint

fifa_panini-1.0.0/fifa_panini/commands/panini/bf_code.py

@@ -0,0 +1,162 @@
+import json
+import time
+from pathlib import Path
+
+import classyclick
+import click
+from tqdm import tqdm
+
+from ...utils.codes import (
+    CODE_ALREADY_USED_MARKER,
+    DEFAULT_REQUEST_DELAY,
+    DEFAULT_STATE_FILE,
+    INVALID_CODE_MARKER,
+    SUFFIX_ALPHABET,
+    TOTAL_SUFFIXES,
+    CodeMethodsMixin,
+)
+from ...utils.panini import (
+    DEFAULT_REQUEST_TIMEOUT,
+    validate_cookie_header,
+)
+from . import PANINI_API_ENDPOINT_META_KEY, PANINI_COOKIE_META_KEY, Panini
+
+
+class BfCode(CodeMethodsMixin, Panini.Command):
+    """Brute-force FIFA Panini promo codes by iterating the final block."""
+
+    cookie: str = classyclick.ContextMeta(PANINI_COOKIE_META_KEY)
+    api_endpoint: str = classyclick.ContextMeta(PANINI_API_ENDPOINT_META_KEY)
+    code_base: str = classyclick.Option(
+        help='Promo code base in XXXX-XXXX-XXXX format; the final block is iterated.',
+    )
+    state_file: Path = classyclick.Option(
+        '-s',
+        default=Path(DEFAULT_STATE_FILE),
+        show_default=True,
+        help='Path used to save resume state.',
+    )
+    dry_run: bool = classyclick.Option(help='Print the request that would be attempted.')
+    request_timeout: float = classyclick.Option(
+        '--timeout',
+        default=DEFAULT_REQUEST_TIMEOUT,
+        show_default=True,
+        help='HTTP request timeout in seconds.',
+    )
+    request_delay: float = classyclick.Option(
+        '--request-delay',
+        default=DEFAULT_REQUEST_DELAY,
+        show_default=True,
+        help='Delay between requests in seconds.',
+    )
+
+    def __call__(self):
+        self.validate_settings()
+
+        if self.dry_run:
+            code = self.next_code()
+            tqdm.write(f'DRY RUN POST {self.unlock_pack_endpoint} code={code}')
+            return
+
+        self.check_code_base()
+        start = self.start_suffix()
+        with tqdm(total=TOTAL_SUFFIXES, initial=start, unit='code') as progress:
+            for code in self.iter_codes(start):
+                progress.set_description(f'Testing {code}')
+                self.save_state(code, self.suffix_from_code(code))
+                response = self.send_code(code)
+
+                if INVALID_CODE_MARKER not in response.text:
+                    tqdm.write(f'Stopping at {code}: response did not contain {INVALID_CODE_MARKER}')
+                    self.print_response(response)
+                    return
+
+                self.save_state(code, self.suffix_from_code(code) + 1)
+                progress.update()
+                if self.request_delay:
+                    time.sleep(self.request_delay)
+
+        raise click.ClickException(f'All {TOTAL_SUFFIXES} suffixes were tried without a non-invalid response.')
+
+    def validate_settings(self):
+        missing = [name for name in ('code_base', 'cookie') if not getattr(self, name)]
+        if missing:
+            raise click.ClickException(
+                f'Missing required setting(s): {", ".join(missing)}. '
+                f'Pass them as options or save them in the config file.'
+            )
+        validate_cookie_header(self.cookie)
+        self.validate_code(self.code_base, '--code-base')
+        if self.request_delay < 0:
+            raise click.ClickException('--request-delay must be greater than or equal to 0.')
+
+    def check_code_base(self):
+        response = self.send_code(self.code_base)
+        if CODE_ALREADY_USED_MARKER not in response.text:
+            print(response.text)
+            raise click.ClickException(
+                f'Code base check failed for {self.code_base}: expected response to contain {CODE_ALREADY_USED_MARKER}.'
+            )
+
+    def iter_codes(self, start=None):
+        if start is None:
+            start = self.start_suffix()
+        for suffix in range(start, TOTAL_SUFFIXES):
+            yield self.format_code(suffix)
+
+    def next_code(self):
+        start = self.start_suffix()
+        if start >= TOTAL_SUFFIXES:
+            raise click.ClickException(f'All {TOTAL_SUFFIXES} suffixes have already been tried for this code base.')
+
+        return self.format_code(start)
+
+    def start_suffix(self):
+        state = self.load_state()
+        if state is None:
+            return 0
+
+        if state.get('code_base') != self.code_base:
+            return 0
+
+        next_suffix = int(state.get('next_suffix', 0))
+        return min(next_suffix, TOTAL_SUFFIXES)
+
+    def load_state(self):
+        state_file = self.state_path
+        if not state_file.exists():
+            return None
+
+        try:
+            with state_file.open() as state:
+                return json.load(state)
+        except (OSError, json.JSONDecodeError) as error:
+            raise click.ClickException(f'Could not read state file {state_file}: {error}') from error
+
+    def save_state(self, code, next_suffix):
+        state = {
+            'code_base': self.code_base,
+            'current_code': code,
+            'next_suffix': next_suffix,
+        }
+        state_file = self.state_path
+        try:
+            state_file.parent.mkdir(parents=True, exist_ok=True)
+            with state_file.open('w') as file:
+                json.dump(state, file, indent=2)
+                file.write('\n')
+        except OSError as error:
+            raise click.ClickException(f'Could not write state file {state_file}: {error}') from error
+
+    def suffix_from_code(self, code):
+        suffix = 0
+        for character in code[-4:]:
+            suffix = suffix * len(SUFFIX_ALPHABET) + SUFFIX_ALPHABET.index(character)
+        return suffix
+
+    def format_code(self, suffix):
+        characters = []
+        for _ in range(4):
+            suffix, index = divmod(suffix, len(SUFFIX_ALPHABET))
+            characters.append(SUFFIX_ALPHABET[index])
+        return f'{self.code_base[:-4]}{"".join(reversed(characters))}'

fifa_panini-1.0.0/fifa_panini/commands/panini/claim.py

@@ -0,0 +1,86 @@
+import datetime as dt
+
+import classyclick
+import click
+
+from ...utils.actions import action, action_with_status, error_message, parse_action_list
+from ...utils.panini import (
+    DEFAULT_REQUEST_TIMEOUT,
+    PaniniClient,
+    validate_cookie_header,
+)
+from . import PANINI_API_ENDPOINT_META_KEY, PANINI_COOKIE_META_KEY, Panini
+
+CLAIM_PACKS_PATH = 'receive_daily_packs.json'
+
+
+class Claim(Panini.Command):
+    """Claim the current FIFA Panini daily packs."""
+
+    cookie: str = classyclick.ContextMeta(PANINI_COOKIE_META_KEY)
+    api_endpoint: str = classyclick.ContextMeta(PANINI_API_ENDPOINT_META_KEY)
+    dry_run: bool = classyclick.Option(help='Print the request that would be attempted.')
+    request_timeout: float = classyclick.Option(
+        '--timeout',
+        default=DEFAULT_REQUEST_TIMEOUT,
+        show_default=True,
+        help='HTTP request timeout in seconds.',
+    )
+
+    @property
+    def panini_client(self):
+        return PaniniClient(self.cookie, self.api_endpoint, self.request_timeout)
+
+    def __call__(self):
+        self.validate_settings()
+
+        if self.dry_run:
+            click.echo(f'DRY RUN POST {self.panini_client.endpoint(CLAIM_PACKS_PATH)} json={{}}')
+            return
+
+        response = self.panini_client.post_json(CLAIM_PACKS_PATH, request_name='claim packs')
+        self.print_response(response)
+
+    def validate_settings(self):
+        if not self.cookie:
+            raise click.ClickException(
+                'Missing required setting(s): cookie. Pass them as options or save them in the config file.'
+            )
+        validate_cookie_header(self.cookie)
+
+    def print_response(self, response):
+        actions = parse_action_list(response)
+
+        receive_daily_packs = action_with_status(actions, 'receive_daily_packs')
+        if not receive_daily_packs:
+            raise click.ClickException('Response did not include receive daily pack information.')
+
+        next_packs_message = self.next_packs_message(actions)
+
+        error_message = self.error_message(receive_daily_packs)
+        if error_message:
+            message = error_message
+            if next_packs_message:
+                message = f'{message}. {next_packs_message}'
+            raise click.ClickException(message)
+
+        received_packs = self.action(actions, 'received_packs')
+        if not received_packs:
+            raise click.ClickException('Response did not include received pack information.')
+
+        click.echo(f'Claimed packs: {received_packs.get("amount", 0)}')
+        click.echo(f'Total packs: {received_packs.get("total_packs", 0)}')
+        if next_packs_message:
+            click.echo(next_packs_message)
+
+    def next_packs_message(self, actions):
+        daily_packs_status = self.action(actions, 'daily_packs_status')
+        new_packs_in_sec = daily_packs_status.get('new_packs_in_sec')
+        if new_packs_in_sec is None:
+            return None
+
+        available_at = dt.datetime.now().astimezone() + dt.timedelta(seconds=new_packs_in_sec)
+        return f'New packs available at: {available_at.strftime("%Y-%m-%d %H:%M:%S %Z").rstrip()}'
+
+    action = staticmethod(action)
+    error_message = staticmethod(error_message)