InstaLooter

https://instalooter.readthedocs.io/en/latest/
Admin
InstaLooter is a program that can download pictures and videos from any profile or hashtag on...
Tokens:36,584
Snippets:356
Trust Score:9.6
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install InstaLooter from PyPI (with superuser rights)

Source: https://instalooter.readthedocs.io/en/latest/_sources/install.rst.txt

Use this command to install InstaLooter globally when you have superuser privileges.

```console
# pip install instaLooter
```

--------------------------------

### Install InstaLooter from PyPI

Source: https://instalooter.readthedocs.io/en/latest/install.html

Use this command to install InstaLooter with pip. Ensure pip and setuptools are installed first. Consider using pip3 for Python 3.

```bash
pip install instaLooter
```

--------------------------------

### Install InstaLooter from PyPI (current user)

Source: https://instalooter.readthedocs.io/en/latest/_sources/install.rst.txt

Install InstaLooter for the current user only if you do not have admin rights.

```console
$ pip install instaLooter --user
```

--------------------------------

### Install InstaLooter from Local Source

Source: https://instalooter.readthedocs.io/en/latest/install.html

After cloning the repository, use pip to install the local version of InstaLooter and its dependencies.

```bash
pip install .
```

--------------------------------

### Install InstaLooter with Metadata Extras

Source: https://instalooter.readthedocs.io/en/latest/install.html

To enable exif metadata features, install InstaLooter with the 'metadata' extras. This command installs for the current user.

```bash
pip install InstaLooter[metadata] --user
```

--------------------------------

### Install InstaLooter from PyPI with metadata extras

Source: https://instalooter.readthedocs.io/en/latest/_sources/install.rst.txt

Install InstaLooter with the 'metadata' extras for exif metadata features, for the current user.

```console
$ pip install instaLooter[metadata] --user
```

--------------------------------

### Install InstaLooter from local source

Source: https://instalooter.readthedocs.io/en/latest/_sources/install.rst.txt

After cloning the repository, use pip to install the local version of InstaLooter and its dependencies.

```console
# pip install .
```

--------------------------------

### Install InstaLooter with development dependencies

Source: https://instalooter.readthedocs.io/en/latest/_sources/install.rst.txt

Install InstaLooter with development dependencies for testing or documentation, for the current user.

```console
$ pip install --user ".[test]"    # install only test dependencies
$ pip install --user ".[doc]"     # install only doc dependencies
$ pip install --user ".[dev]"     # install all dev dependencies
```

--------------------------------

### Batch Configuration for Downloading Videos

Source: https://instalooter.readthedocs.io/en/latest/_sources/batch.rst.txt

Example configuration to download 3 new videos from specified hashtags. Sets parameters like 'videos-only', 'new', 'num-to-dl', and 'hashtags'.

```ini
[Vids]
videos-only = true
new = true
num-to-dl = 3
hashtags =
    funny: ~/Videos
    nsfw: ~/Videos
```

--------------------------------

### Install Development Dependencies

Source: https://instalooter.readthedocs.io/en/latest/install.html

To install development dependencies for testing or documentation building, use the 'test', 'doc', or 'dev' extras with pip. These commands install for the current user.

```bash
pip install --user ".[test]"    # install only test dependencies
```

```bash
pip install --user ".[doc]"     # install only doc dependencies
```

```bash
pip install --user ".[dev]"     # install all dev dependencies
```

--------------------------------

### InstaLooter Filename Template Examples

Source: https://instalooter.readthedocs.io/en/latest/usage.html

Examples demonstrating the use of the -T argument to specify custom filename templates for downloaded files. These templates can include variables like username, datetime, likescount, width, height, and id.

```bash
instaLooter <profile> -T {username}.{datetime}
```

```bash
instaLooter <profile> -T {username}-{likescount}-{width}x{height}.{id}
```

```bash
instaLooter <profile> -T {username}.{code}.something_constant
```

--------------------------------

### Clone InstaLooter Repository

Source: https://instalooter.readthedocs.io/en/latest/install.html

Clone the InstaLooter GitHub repository and navigate into the directory. This is the first step to installing from source.

```bash
git clone https://github.com/althonos/InstaLooter
cd InstaLooter
```

--------------------------------

### Enable and Start SystemD Timer

Source: https://instalooter.readthedocs.io/en/latest/_sources/cron.rst.txt

Commands to enable and start a SystemD timer. Use the '--user' flag for user-specific timers.

```console
# systemctl start looter.timer && systemctl enable looter.timer
$ systemctl --user start looter.timer && systemctl --user enable looter.timer
```

--------------------------------

### Install InstaLooter for Current User

Source: https://instalooter.readthedocs.io/en/latest/install.html

If you don't have admin rights, use this command to install InstaLooter for the current user only.

```bash
pip install instaLooter --user
```

--------------------------------

### Filename Templating Examples

Source: https://instalooter.readthedocs.io/en/latest/_sources/usage.rst.txt

These examples demonstrate how to use the -T option to customize filenames with variables like username, datetime, likescount, width, height, and id. Ensure at least one of 'id' or 'code' is used for unique filenames.

```console
$ instaLooter <profile> -T {username}.{datetime}
```

```console
$ instaLooter <profile> -T {username}-{likescount}-{width}x{height}.{id}
```

```console
$ instaLooter <profile> -T {username}.{code}.something_constant
```

--------------------------------

### Initialize Download Workers

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/looters.html

Sets up and starts multiple InstaDownloader worker threads. Each worker consumes from a shared queue and downloads media to a specified destination. Use this to enable parallel media downloads.

```python
def _init_workers(self,
                      pbar,         # type: Union[ProgressBar, Iterable, None]
                      destination,  # type: fs.base.FS
                      ): # type: (...) -> Tuple[List[InstaDownloader], Queue]

        workers = []        # type: List[InstaDownloader]
        queue = Queue()     # type: Queue

        for _ in six.moves.range(self.jobs):
            worker = InstaDownloader(
                queue=queue,
                destination=destination,
                namegen=self.namegen,
                add_metadata=self.add_metadata,
                dump_json=self.dump_json,
                dump_only=self.dump_only,
                pbar=pbar,
                session=self.session)
            worker.start()
            workers.append(worker)

        return workers, queue
```

--------------------------------

### SystemD Timer File Configuration

Source: https://instalooter.readthedocs.io/en/latest/cron.html

Defines a SystemD timer to schedule the execution of a service. This example sets the timer to run hourly after booting.

```ini
[Unit]
Description=run my custom periodic instagram looter hourly

[Timer]
# Time to wait after booting before we run first time
OnBootSec=10min
# Time between running each consecutive time
OnUnitActiveSec=1h
Unit=looter.service

```

--------------------------------

### Progress Bar Initialization

Source: https://instalooter.readthedocs.io/en/latest/instalooter/pbar.html

Initializes a progress bar with various configuration options. The `initial` parameter sets the starting count, `position` manages bar placement for multiple bars, `postfix` adds extra statistics, `unit_divisor` scales units, `write_bytes` handles encoding, `lock_args` are for refresh, `nrows` sets screen height, `colour` customizes bar color, `delay` controls display timing, and `gui` is an internal parameter for graphical output.

```APIDOC
## Progress Bar Initialization

### Description
Initializes a progress bar with various configuration options.

### Parameters
#### Optional Parameters
- **initial** (int or float) - The initial counter value. Defaults to 0.
- **position** (int) - The line offset to print this bar. Automatic if unspecified.
- **postfix** (dict or *) - Additional stats to display at the end of the bar.
- **unit_divisor** (float) - Defaults to 1000, ignored unless `unit_scale` is True.
- **write_bytes** (bool) - If True, bytes will be written. Defaults to None.
- **lock_args** (tuple) - Passed to `refresh` for intermediate output.
- **nrows** (int) - The screen height. Attempts to use environment height if unspecified.
- **colour** (str) - Bar colour (e.g. ‘green’, ‘#00ff00’).
- **delay** (float) - Don’t display until this many seconds have elapsed. Defaults to 0.
- **gui** (bool) - Internal parameter for graphical output. Defaults to False.

### Returns
- **out** (decorated iterator)
```

--------------------------------

### main

Source: https://instalooter.readthedocs.io/en/latest/instalooter/index.html

The entry point for running Instalooter from the command line interface.

```APIDOC
## main

### Description
Run from the command line interface.

### Function
`instalooter.cli.main(argv, stream)`
```

--------------------------------

### instalooter.cli.main

Source: https://instalooter.readthedocs.io/en/latest/instalooter/cli.html

The main entry point for running Instalooter from the command line. It accepts a list of arguments and an optional stream for error messages.

```APIDOC
## instalooter.cli.main

### Description
Runs the Instalooter program from the command line interface. It processes provided arguments and directs error messages to a specified stream or the standard error handler.

### Method
Function Call

### Parameters
#### Path Parameters
* **argv** (list) - Optional - The positional arguments to read. Defaults to `sys.argv` to use CLI arguments.
* **stream** (IOBase) - Optional - A file where to write error messages. Leave to `None` to use the `StandardErrorHandler` for logs, and `sys.stderr` for error messages.

### Returns
An error code, or 0 if the program executed successfully.

### Return Type
int
```

--------------------------------

### Command Line Interface

Source: https://instalooter.readthedocs.io/en/latest/_sources/instalooter/index.rst.txt

The main entry point for the Instalooter command-line interface.

```APIDOC
## main

### Description
Executes the Instalooter command-line interface, handling user arguments and initiating the download process.
```

--------------------------------

### Initialize Destination Filesystem

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/looters.html

Opens a filesystem for destination, either from a FS URL or an existing FS instance. It handles decoding binary types to UTF-8 and optionally creates the filesystem if it doesn't exist. It returns the FS instance and a boolean indicating if it should be closed later.

```python
    def _init_destfs(self, destination, create=True):
        # type: (Union[str, fs.base.FS], bool) -> Tuple[fs.base.FS, bool]
        """Open a filesystem either from a FS URL or filesystem instance.

        Arguments:
            destination (~fs.base.FS or str): the destination filesystem
                to open, as a filesystem instance or FS URL.
            create (bool): whether or not to create a
                filesystem if it does not exist.

        Returns:
            (~fs.base.FS, bool): the open FS, and whether to close it.

        """
        close_destination = False
        if isinstance(destination, six.binary_type):
            destination = destination.decode('utf-8')
        if isinstance(destination, six.text_type):
            destination = fs.open_fs(destination, create=create)
            close_destination = True
        if not isinstance(destination, fs.base.FS):
            raise TypeError("<destination> must be a FS URL or FS instance.")
        return destination, close_destination
```

--------------------------------

### Instalooter CLI Main Function Logic

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/cli.html

This snippet outlines the core logic within the Instalooter CLI, including argument processing, user login, download parameters, time frame extraction, and initiating the download process. It also includes comprehensive error handling for exceptions and keyboard interrupts.

```python
            # Attempt to login and extract the timeframe
            if args['--username']:
                login(args)
            if args['--num-to-dl']:
                args['--num-to-dl'] = int(args['--num-to-dl'])
            try:
                if args['--time'] is not None:
                    args['--time'] = get_times_from_cli(args['--time'])
            except ValueError as ve:
                _print("invalid format for --time parameter:", args["--time"])
                _print("    (format is [D]:[D] where D is an ISO 8601 date)")
                return 1

            logger.debug("Opening destination filesystem")
            dest_url = args.get('<directory>') or os.getcwd()
            dest_fs = fs.open_fs(dest_url, create=True)

            logger. 
            n = looter.download(
                destination=dest_fs,
                media_count=args['--num-to-dl'],
                timeframe=args['--time'],
                new_only=args['--new'],
                pgpbar_cls=None if args['--quiet'] else TqdmProgressBar,
                dlpbar_cls=None if args['--quiet'] else TqdmProgressBar)
            if n > 1:
                logger.success("Downloaded %i posts.", n)
            elif n == 1:
                logger.success("Downloaded %i post.", n)

        except (Exception, KeyboardInterrupt) as e:
            from .threadutils import threads_force_join, threads_count
            # Show error traceback if any
            if not isinstance(e, KeyboardInterrupt):
                logger.critical("%s", e)
                if args["--traceback"]:
                    traceback.print_exc()
            else:
                logger.critical("Interrupted")
            # Close remaining threads spawned by InstaLooter.download
            count = threads_count()
            if count:
                logger.notice("Terminating %i remaining workers...", count)
                threads_force_join()
            # Return the error number if any
            errno = e.errno if hasattr(e, "errno") else None
            return errno if errno is not None else 1

        else:
            return 0

        finally:
            logger.debug("Closing destination filesystem")
            try:
                dest_fs.close()
            except Exception:
                pass

```

--------------------------------

### Batch Media Download Loop

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/batch.html

Iterates through defined targets, initializing and configuring Instalooter for each. Handles login, download parameters, and error logging.

```python
                for target, directory in six.iteritems(targets):
                    try:
                        logger.info("Downloading {} to {}".format(target, directory))
                        looter = looter_cls(
                            target,
                            add_metadata=self._getboolean(section_id, 'add-metadata', False),
                            get_videos=self._getboolean(section_id, 'get-videos', False),
                            videos_only=self._getboolean(section_id, 'videos-only', False),
                            jobs=self._getint(section_id, 'jobs', 16),
                            template=self._get(section_id, 'template', '{id}'),
                            dump_json=self._getboolean(section_id, 'dump-json', False),
                            dump_only=self._getboolean(section_id, 'dump-only', False),
                            extended_dump=self._getboolean(section_id, 'extended-dump', False),
                            session=session)

                        if self.parser.has_option(section_id, 'username'):
                            looter.logout()
                            username = self._get(section_id, 'username')
                            password = self._get(section_id, 'password') or \
                                getpass.getpass('Password for "{}": '.format(username))
                            looter.login(username, password)

                        n = looter.download(
                            directory,
                            media_count=self._getint(section_id, 'num-to-dl'),
                            # FIXME: timeframe=self._get(section_id, 'timeframe'),
                            new_only=self._getboolean(section_id, 'new', False),
                            pgpbar_cls=None if quiet else TqdmProgressBar,
                            dlpbar_cls=None if quiet else TqdmProgressBar)

                        logger.success("Downloaded %i medias !", n) 

                    except Exception as exception:
                        logger.error(six.text_type(exception))
```

--------------------------------

### get_post_info

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/looters.html

Get media information from a given post code. This method fetches detailed information about a specific Instagram post using its shortcode.

```APIDOC
## get_post_info

### Description
Get media information from a given post code.

### Arguments
- **code** (str): the code of the post (can be obtained either from the ``shortcode`` attribute of media dictionaries, or from a post URL: ``https://www.instagram.com/p/<code>/``)

### Returns
- **dict**: a media dictionaries, in the format used by Instagram.
```

--------------------------------

### TimedMediasIterator Class

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/medias.html

An iterator that yields media items within a specified timeframe. It extends MediasIterator and filters media based on start and end dates.

```python
[docs]class TimedMediasIterator(MediasIterator):
    """An iterator over the medias within a specific timeframe.
    """

    @staticmethod
    def get_times(timeframe):
        if timeframe is None:
            timeframe = (None, None)
        try:
            start_time = timeframe[0] or datetime.date.today()
            end_time = timeframe[1] or datetime.date.fromtimestamp(0)
        except (IndexError, AttributeError):
            raise TypeError("'timeframe' must be a couple of dates!")
        return start_time, end_time

    def __init__(self, page_iterator, timeframe=None):
        super(TimedMediasIterator, self).__init__(page_iterator)
        self.start_time, self.end_time = self.get_times(timeframe)


[docs]    def __next__(self):
        number_old = 0
        while True:
            media = super(TimedMediasIterator, self).__next__()
            timestamp = media.get('taken_at_timestamp') or media['date']
            media_date = type(self.start_time).fromtimestamp(timestamp)

            if self.start_time >= media_date >= self.end_time:
                return media
            elif media_date < self.end_time:
                number_old += 1
                if number_old >= PageIterator.PAGE_SIZE:
                    self._finished = True
                    raise StopIteration


    if six.PY2:
        next = __next__
```

--------------------------------

### Get users from comments on posts

Source: https://instalooter.readthedocs.io/en/latest/examples.html

Retrieves a set of unique usernames that have commented on posts from a specified profile. Requires fetching post information and iterating through comments.

```python
from instalooter.looters import ProfileLooter
looter = ProfileLooter("franz_ferdinand")

users = set()
for media in looter.medias():
   info = looter.get_post_info(media['shortcode'])
   for comment in post_info['edge_media_to_comment']['edges']:
       user = comment['node']['owner']['username']
       users.add(user)


```

--------------------------------

### SystemD Service File Configuration

Source: https://instalooter.readthedocs.io/en/latest/cron.html

Defines a SystemD service for running InstaLooter. The 'ExecStart' line should be customized with desired parameters.

```ini
[Unit]
Description=my custom periodic instagram looter

[Service]
Type=oneshot
ExecStart=/usr/bin/env python -m instaLooter <the parameters I want>

```

--------------------------------

### InstaLooter Constructor

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/looters.html

Initializes the InstaLooter object with various options for downloading media. It sets up the session, retrieves necessary tokens, and registers a cleanup function.

```APIDOC
## InstaLooter Constructor

### Description
Initializes the InstaLooter object with various options for downloading media. It sets up the session, retrieves necessary tokens, and registers a cleanup function.

### Parameters
#### Arguments
- **add_metadata** (bool): Add date and comment metadata to the downloaded pictures.
- **get_videos** (bool): Also get the videos from the given target.
- **videos_only** (bool): Only download videos (implies ``get_videos=True``).
- **jobs** (bool): the number of parallel threads to use to download media (12 or more is advised to have a true parallel download of media files).
- **template** (str): a filename format, in Python new-style-formatting format. See the the :ref:`Template` page of the documentation for available keys.
- **dump_json** (bool): Save each resource metadata to a JSON file next to the actual image/video.
- **dump_only** (bool): Only save metadata and discard the actual resource.
- **extended_dump** (bool): Attempt to fetch as much metadata as possible, at the cost of more time. Set to `True` if, for instance, you always want the top comments to be downloaded in the dump.
- **session** (~requests.Session or None): a `requests` session, or `None` to create a new one.
```

--------------------------------

### SystemD Service File for Periodic Looter

Source: https://instalooter.readthedocs.io/en/latest/_sources/cron.rst.txt

Defines a SystemD service to run instaLooter with specified parameters. Ensure the instaLooter module is installed in a location accessible by the systemd manager.

```ini
[Unit]
Description=my custom periodic instagram looter

[Service]
Type=oneshot
ExecStart=/usr/bin/env python -m instaLooter <the parameters I want>
```

--------------------------------

### TimedMediasIterator

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/medias.html

An iterator that filters media items within a specified timeframe. It inherits from MediasIterator and adds logic to check the timestamp of each media item against the provided start and end times.

```APIDOC
class TimedMediasIterator(MediasIterator):
    """An iterator over the medias within a specific timeframe.
    """

    @staticmethod
    def get_times(timeframe):
        if timeframe is None:
            timeframe = (None, None)
        try:
            start_time = timeframe[0] or datetime.date.today()
            end_time = timeframe[1] or datetime.date.fromtimestamp(0)
        except (IndexError, AttributeError):
            raise TypeError("'timeframe' must be a couple of dates!")
        return start_time, end_time

    def __init__(self, page_iterator, timeframe=None):
        super(TimedMediasIterator, self).__init__(page_iterator)
        self.start_time, self.end_time = self.get_times(timeframe)

    def __next__(self):
        number_old = 0
        while True:
            media = super(TimedMediasIterator, self).__next__()
            timestamp = media.get('taken_at_timestamp') or media['date']
            media_date = type(self.start_time).fromtimestamp(timestamp)

            if self.start_time >= media_date >= self.end_time:
                return media
            elif media_date < self.end_time:
                number_old += 1
                if number_old >= PageIterator.PAGE_SIZE:
                    self._finished = True
                    raise StopIteration

    if six.PY2:
        next = __next__
```

--------------------------------

### Download using Batch Configuration Weekly with Cron

Source: https://instalooter.readthedocs.io/en/latest/_sources/cron.rst.txt

Schedules a task to run instaLooter using a batch configuration file ('~/myLooter.ini') every Sunday at 00:00.

```console
@weekly /usr/bin/env python -m instaLooter batch ~/myLooter.ini
```

--------------------------------

### Extract Users from Mentions with instaLooter

Source: https://instalooter.readthedocs.io/en/latest/_sources/examples.rst.txt

Gathers a set of unique usernames mentioned in the tagged users list of posts from a given Instagram profile. This example iterates through media and extracts tagged user information.

```python
from instalooter.looters import ProfileLooter
looter = ProfileLooter("mandodiaomusic")

users = set()
for media in looter.medias():
   info = looter.get_post_info(media['shortcode'])
   for comment in post_info['edge_media_to_tagged_user']['edges']:
       user = comment['node']['user']['username']
       users.add(user)
```

--------------------------------

### run_all Method

Source: https://instalooter.readthedocs.io/en/latest/instalooter/batch.html

Executes all the download jobs defined in the batch configuration file.

```APIDOC
## Method `run_all`

### Description
Run all the jobs specified in the configuration file.
```

--------------------------------

### Get users from mentions in posts

Source: https://instalooter.readthedocs.io/en/latest/examples.html

Extracts a set of unique usernames mentioned in the tagged users list of posts from a given profile. This involves fetching post details and iterating through tagged user edges.

```python
from instalooter.looters import ProfileLooter
looter = ProfileLooter("mandodiaomusic")

users = set()
for media in looter.medias():
   info = looter.get_post_info(media['shortcode'])
   for comment in post_info['edge_media_to_tagged_user']['edges']:
       user = comment['node']['user']['username']
       users.add(user)


```

--------------------------------

### Running InstaLooter in Batch Mode

Source: https://instalooter.readthedocs.io/en/latest/_sources/batch.rst.txt

Command to execute InstaLooter using a batch configuration file. Replace '/path/to/your/batch.ini' with the actual path to your configuration file.

```console
instaLooter batch /path/to/your/batch.ini
```

--------------------------------

### Instalooter Batch Runner Initialization

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/batch.html

Initializes the BatchRunner with a configuration handle and optional arguments. Handles both file paths and file-like objects for configuration.

```python
# coding: utf-8
"""Run several jobs sharing a session using a configuration file.
"""
from __future__ import absolute_import
from __future__ import unicode_literals

import io
import getpass
import logging
import typing

import six
import verboselogs
from requests import Session

from .looters import HashtagLooter, ProfileLooter
from .pbar import TqdmProgressBar

if typing.TYPE_CHECKING:
    from typing import Any, Dict, Mapping, Optional, Text, Type, Union
    from .looter import InstaLooter


#: The module logger
logger = verboselogs.VerboseLogger(__name__)




class BatchRunner(object):
    """Run ``InstaLooter`` in batch mode, using a configuration file.
    """

    _CLS_MAP = {
        'users': ProfileLooter,
        'hashtag': HashtagLooter,
    }  # type: Mapping[Text, Type[InstaLooter]]

    def __init__(self, handle, args=None):
        # type: (Any, Optional[Mapping[Text, Any]]) -> None

        close_handle = False
        if isinstance(handle, six.binary_type):
            handle = handle.decode('utf-8')
        if isinstance(handle, six.text_type):
            _handle = open(handle)  # type: typing.IO
            close_handle = True
        else:
            _handle = handle

        try:
            self.args = args or {}
            self.parser = six.moves.configparser.ConfigParser()
            getattr(self.parser, "readfp" if six.PY2 else "read_file")(_handle)
        finally:
            if close_handle:
                _handle.close()

```

--------------------------------

### InstaDownloader Constructor

Source: https://instalooter.readthedocs.io/en/latest/instalooter/worker.html

Initializes the background InstaLooter worker. This constructor should always be called with keyword arguments.

```APIDOC
## InstaDownloader(queue, destination, namegen, add_metadata=False, dump_json=False, dump_only=False, pbar=None, session=None)

### Description
The background InstaLooter worker class.

### Parameters
#### Path Parameters
- **queue** (any) - Description not provided
- **destination** (any) - Description not provided
- **namegen** (any) - Description not provided
- **add_metadata** (bool) - Optional - Description not provided
- **dump_json** (bool) - Optional - Description not provided
- **dump_only** (bool) - Optional - Description not provided
- **pbar** (any) - Optional - Description not provided
- **session** (any) - Optional - Description not provided
```

--------------------------------

### Download Videos with Instalooter

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/looters.html

Use this method to download only video media. It's a shortcut for the main `download` method, filtering for video content.

```python
def download_videos(self,
                        destination,
                        media_count=None,
                        timeframe=None,
                        new_only=False,
                        pgpbar_cls=None,
                        dlpbar_cls=None
                        ):
        # type: (...) -> int
        """Download all videos to the provided destination.

        Actually a shortcut for `.download` with ``condition`` set
        to accept only videos.

        """
        return self.download(
            destination,
            condition=lambda media: media["is_video"],
            media_count=media_count,
            timeframe=timeframe,
            new_only=new_only,
            pgpbar_cls=pgpbar_cls,
            dlpbar_cls=dlpbar_cls,
        )
```

--------------------------------

### Running InstaLooter in Batch Mode

Source: https://instalooter.readthedocs.io/en/latest/batch.html

Execute the batch mode by providing the path to your batch configuration file as an argument to the `instaLooter batch` command.

```bash
instaLooter batch /path/to/your/batch.ini

```

--------------------------------

### Batch Download

Source: https://instalooter.readthedocs.io/en/latest/_sources/usage.rst.txt

Initiates a batch download process using instructions from a specified batch file. Refer to the batch documentation for the file format.

```console
$ instaLooter batch <batch_file>
```

--------------------------------

### Configuring Download Parameters

Source: https://instalooter.readthedocs.io/en/latest/batch.html

Set various download parameters within a section, such as enabling video downloads, setting the number of jobs, or specifying a template for filenames.

```ini
[Vids]
videos-only = true
new = true
num-to-dl = 3
hashtags =
    funny: ~/Videos
    nsfw: ~/Videos


```

--------------------------------

### InstaDownloader Worker Initialization and Run

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/looters.html

Initializes an InstaDownloader worker with specified parameters and runs it. This is used for downloading media from Instagram.

```python
worker = InstaDownloader(
            queue=queue,
            destination=destination,
            namegen=self.namegen,
            add_metadata=self.add_metadata,
            dump_json=self.dump_json,
            dump_only=self.dump_only,
            pbar=None,
            session=self.session)
        worker.run()

        return medias_queued
```

--------------------------------

### Clone InstaLooter repository from GitHub

Source: https://instalooter.readthedocs.io/en/latest/_sources/install.rst.txt

Clone the InstaLooter repository from GitHub and navigate into the cloned directory.

```console
$ git clone https://github.com/althonos/InstaLooter
$ cd InstaLooter
```

--------------------------------

### General Media Download with Instalooter

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/looters.html

The core method for downloading media. Allows specifying a custom condition to filter media, setting a time frame, and controlling download behavior with `new_only`. Supports custom progress bar classes for page scraping and file downloads.

```python
def download(self,
                 destination,
                 condition=None,
                 media_count=None,
                 timeframe=None,
                 new_only=False,
                 pgpbar_cls=None,
                 dlpbar_cls=None
                 ):
        # type: (...) -> int
        """Download all medias passing ``condition`` to destination.

        Arguments:
            destination (~fs.base.FS or str): the filesystem where to
                store the downloaded files, as a filesystem instance or
                FS URL.
            condition (function): the condition to filter the
                medias with. If `None` is given, a function is created using
                the ``get_videos`` and ``videos_only`` passed at object
                initialisation.
            media_count (int or None): the maximum number of medias
                to download. Leave to ``None`` to download everything from
                the target. *Note that more files can be downloaded, since
                a post with multiple images/videos is considered to be a
                single media*.
            timeframe (tuple or None): a tuple of two `~datetime.datetime`
                objects to enforce a time frame (the first item must be
                more recent). Leave to `None` to ignore times.
            new_only (bool): stop media discovery when already
                downloaded medias are encountered.
            pgpbar_cls (type or None): an optional `~.pbar.ProgressBar`
                subclass to use to display page scraping progress.
            dlpbar_cls (type or None): an optional `~.pbar.ProgressBar`
                subclass to use to display file download progress.

        Returns:
            int: the number of queued medias.

            May not be equal to the number of downloaded medias if some
            errors occurred during background download.

        """
        # Open the destination filesystem
        destination, close_destination = self._init_destfs(destination)

        # Create an iterator over the pages with an optional progress bar
        pages_iterator = self.pages()   # type: Iterable[Dict[Text, Any]]
        pages_iterator = pgpbar = self._init_pbar(pages_iterator, pgpbar_cls)

        # Create an iterator over the medias
        medias_iterator = self._medias(iter(pages_iterator), timeframe)

        # Create the media download bar from a dummy iterator
        dlpbar = self._init_pbar(
            six.moves.range(length_hint(medias_iterator)), dlpbar_cls)

```

--------------------------------

### InstaLooter Parameters

Source: https://instalooter.readthedocs.io/en/latest/instalooter/looters.html

Parameters that can be set during the initialization of an InstaLooter object to control download behavior.

```APIDOC
## InstaLooter Parameters

### Description
These parameters configure the behavior of the InstaLooter instance for downloading media.

### Parameters
#### Initialization Parameters
- **add_metadata** (bool) – Add date and comment metadata to the downloaded pictures.
- **get_videos** (bool) – Also get the videos from the given target.
- **videos_only** (bool) – Only download videos (implies `get_videos=True`).
- **jobs** (bool) – the number of parallel threads to use to download media (12 or more is advised to have a true parallel download of media files).
- **template** (str) – a filename format, in Python new-style-formatting format. See the the Template page of the documentation for available keys.
- **dump_json** (bool) – Save each resource metadata to a JSON file next to the actual image/video.
- **dump_only** (bool) – Only save metadata and discard the actual resource.
- **extended_dump** (bool) – Attempt to fetch as much metadata as possible, at the cost of more time. Set to `True` if, for instance, you always want the top comments to be downloaded in the dump.
- **session** (Session or None) – a `requests` session, or `None` to create a new one.
```

--------------------------------

### BatchRunner

Source: https://instalooter.readthedocs.io/en/latest/instalooter/index.html

Enables running InstaLooter in batch mode using a configuration file.

```APIDOC
## BatchRunner

### Description
Run `InstaLooter` in batch mode, using a configuration file.

### Class
`instalooter.batch.BatchRunner`
```

--------------------------------

### InstaDownloader Class Initialization

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/worker.html

Initializes the background worker with download queue, destination, naming generator, and metadata options. It sets up retry mechanisms for download methods.

```python
# coding: utf-8
"""Background download thread.
"""
from __future__ import absolute_import
from __future__ import unicode_literals

import io
import operator
import threading
import time

import requests
import six
import tenacity

from ._impl import PIL, piexif, json



[docs]class InstaDownloader(threading.Thread):
    """The background InstaLooter worker class.
    """

    _tenacity_options = {
        "stop": tenacity.stop_after_attempt(5),
        "wait": tenacity.wait_exponential(1, 10),
    }

    def __init__(self, 
                 queue, 
                 destination, 
                 namegen, 
                 add_metadata=False, 
                 dump_json=False, 
                 dump_only=False, 
                 pbar=None, 
                 session=None):

        super(InstaDownloader, self).__init__()

        self.queue = queue
        self.destination = destination
        self.namegen = namegen
        self.session = session or requests.Session()
        self.pbar = pbar

        self.dump_only = dump_only
        self.dump_json = dump_json or dump_only
        self.add_metadata = add_metadata

        self._killed = False
        self._downloading = None

        retry = tenacity.retry(**self._tenacity_options)
        self._DOWNLOAD_METHODS = {
            "GraphImage": retry(self._download_image),
            "GraphVideo": retry(self._download_video),
            "GraphSidecar": self._download_sidecar,
        }
```

--------------------------------

### ProfileLooter Initialization

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/looters.html

Initializes a ProfileLooter to download media from a specific Instagram username. Accepts standard InstaLooter initialization arguments.

```python
class ProfileLooter(InstaLooter):
    """A looter targeting medias on a user profile.
    """

    def __init__(self, username, **kwargs):
        # type: (str, **Any) -> None
        """Create a new profile looter.

        Arguments:
            username (str): the username of the profile.

        See `InstaLooter.__init__` for more details about accepted
        keyword arguments.

        """
        super(ProfileLooter, self).__init__(**kwargs)
        self._username = username
        self._owner_id = None
```

--------------------------------

### Specifying Users and Hashtags in Batch Config

Source: https://instalooter.readthedocs.io/en/latest/_sources/batch.rst.txt

Define users and hashtags to download from within a section. Each entry maps a name to a download directory path. Supports multiple entries per parameter.

```ini
[Video Games]
users =
    borderlands: /tmp/borderlands
    ffxv: /tmp/ffxv
hashtags =
    nierautomata: /tmp/nier

[Music]
users =
   perm36 : ~/Music/Perm36
```

--------------------------------

### Download Pictures with Instalooter

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/looters.html

Use this method to download only image media. It's a shortcut for the main `download` method, filtering for non-video content.

```python
def download_pictures(self,
                          destination,
                          media_count=None,
                          timeframe=None,
                          new_only=False,
                          pgpbar_cls=None,
                          dlpbar_cls=None
                          ):
        # type: (...) -> int
        """Download all the pictures to the provided destination.

        Actually a shortcut for `.download` with ``condition`` set
        to accept only images.

        """
        return self.download(
            destination,
            condition=lambda media: not media["is_video"],
            media_count=media_count,
            timeframe=timeframe,
            new_only=new_only,
            pgpbar_cls=pgpbar_cls,
            dlpbar_cls=dlpbar_cls,
        )
```

--------------------------------

### InstaDownloader Run Method

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/worker.html

The main loop for the worker thread. It continuously fetches media from the queue, processes downloads and JSON dumping, and updates the progress bar until a termination signal is received.

```python
    def run(self):
        while not self._killed:
            try:
                media = self.queue.get_nowait()

                # Received a poison pill: break the loop
                if media is None:
                    self._killed = True

                else:
                    # Download media
                    if not self.dump_only:
                        self._DOWNLOAD_METHODS[media["__typename"]](media)
                    # Dump JSON metadata if needed
                    if self.dump_json:
                        self._dump(media)
                    # Update progress bar if any
                    if self.pbar is not None and not self._killed:
                        with self.pbar.get_lock():
                            self.pbar.update()

                self.queue.task_done()

            except six.moves.queue.Empty:
                time.sleep(1)
```

--------------------------------

### Instalooter.looters.download_videos

Source: https://instalooter.readthedocs.io/en/latest/instalooter/looters.html

Downloads all videos to the provided destination. This is a shortcut for the `download` function with a condition set to accept only videos.

```APIDOC
## instalooter.looters.download_videos

### Description
Download all videos to the provided destination. Actually a shortcut for `download` with `condition` set to accept only videos.

### Parameters
- **destination** (_FS_ or _str_) – the filesystem where to store the downloaded files, as a filesystem instance or FS URL.
- **media_count** (_int_ or _None_) – the maximum number of medias to download. Leave to `None` to download everything from the target. _Note that more files can be downloaded, since a post with multiple images/videos is considered to be a single media_.
- **timeframe** (_tuple_ or _None_) – a tuple of two `datetime` objects to enforce a time frame (the first item must be more recent). Leave to `None` to ignore times.
- **new_only** (_bool_) – stop media discovery when already downloaded medias are encountered.
- **pgpbar_cls** (_type_ or _None_) – an optional `ProgressBar` subclass to use to display page scraping progress.
- **dlpbar_cls** (_type_ or _None_) – an optional `ProgressBar` subclass to use to display file download progress.
```

--------------------------------

### Download Image Method

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/worker.html

Handles the download of a single image. It checks if the file already exists before downloading and writing to the destination.

```python
    def _download_image(self, media):
        url = media['display_url']
        filename = self.namegen.file(media)

        if self.destination.exists(filename):
            return

        # FIXME: find a way to remove failed temporary downloads
        with self.destination.open(filename, "wb") as f:
            with self.session.get(url) as res:
                f.write(res.content)
        self._set_time(media, filename)
```

--------------------------------

### Download Video Method

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/worker.html

Handles the download of a video, streaming it in chunks to the destination. It also checks for existing files.

```python
    def _download_video(self, media):
        url = media['video_url']
        filename = self.namegen.file(media)

        if self.destination.exists(filename):
            return

        # FIXME: find a way to remove failed temporary downloads
        with self.destination.open(filename, "wb") as f:
            with self.session.get(url) as res:
                for chunk in res.iter_content(io.DEFAULT_BUFFER_SIZE):
                    f.write(chunk)
        self._set_time(media, filename)
```

--------------------------------

### Download by Hashtag

Source: https://instalooter.readthedocs.io/en/latest/usage.html

This command downloads pictures and videos associated with a given hashtag. A directory must be specified to save the downloaded content.

```bash
$ instaLooter hashtag <hashtag> <directory> [options]

```

--------------------------------

### Initialize Workers and Queue Media

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/looters.html

Initializes worker threads and a queue for downloading media. It registers a shutdown hook for workers and fills the queue with media from an iterator. Progress bars are updated, and a warning is issued if no media is found. Finally, it signals workers to finish and joins them.

```python
        # Start a group of workers
        workers, queue = self._init_workers(
            dlpbar if dlpbar_cls is not None else None, destination)

        # Make sure exiting the main thread will shutdown workers
        atexit.register(self._shutdown_workers, workers)

        # Queue all medias
        medias_queued = self._fill_media_queue(
            queue, destination, medias_iterator, media_count,
            new_only, condition)

        # Once queuing the medias is fininished, finish the page progress bar
        # and set a new maximum on the download progress bar.
        if pgpbar_cls is not None:
            pgpbar.finish()                         # type: ignore
        if dlpbar_cls is not None:
            dlpbar.set_maximum(medias_queued)       # type: ignore

        # If no medias were queued, issue a warning
        # TODO: refine warning depending on download parameters
        if medias_queued == 0:
            warnings.warn("No medias found.")

        # Add poison pills to the queue and wait for workers to finish
        self._poison_workers(workers, queue)
        self._join_workers(workers, queue)

        # Once downloading is finished, finish the download progress bar
        # and close the destination if needed.
        if dlpbar_cls is not None:
            dlpbar.finish()                        # type: ignore
        if close_destination:
            destination.close()

        return medias_queued
```

--------------------------------

### Specifying User and Hashtag Targets

Source: https://instalooter.readthedocs.io/en/latest/batch.html

Define users and hashtags to download from within a section. Each entry maps a name to a local directory path for media storage.

```ini
[Video Games]
users =
    borderlands: /tmp/borderlands
    ffxv: /tmp/ffxv
hashtags =
    nierautomata: /tmp/nier

[Music]
users =
   perm36 : ~/Music/Perm36


```

--------------------------------

### TqdmProgressBar Implementation

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/pbar.html

A concrete implementation of the ProgressBar abstract class that utilizes the `tqdm` library for displaying progress. It overrides methods to integrate with `tqdm`'s functionality.

```python
class TqdmProgressBar(tqdm.tqdm, ProgressBar):
    """A progress bar using the `tqdm` library.
    """

    def __init__(self, it, *args, **kwargs):  # noqa: D102, D107
        kwargs["leave"] = False
        super(TqdmProgressBar, self).__init__(it, *args, **kwargs)
        ProgressBar.__init__(self, it)


    def set_maximum(self, maximum):  # noqa: D102
        self.total = maximum


    def finish(self):  # noqa: D102
        self.close()
```

--------------------------------

### Download by Hashtag

Source: https://instalooter.readthedocs.io/en/latest/_sources/usage.rst.txt

This command downloads pictures and videos associated with a given hashtag. You must specify the hashtag and the directory where the files will be saved.

```console
$ instaLooter hashtag <hashtag> <directory> [options]
```

--------------------------------

### BatchRunner Helper Methods

Source: https://instalooter.readthedocs.io/en/latest/_modules/instalooter/batch.html

Provides helper methods for retrieving boolean, integer, and string values from the configuration parser with default value support.

```python
    @typing.overload
    def _getboolean(self, section_id, key, default):
        # type: (Text, Text, bool) -> bool
        pass

    @typing.overload
    def _getboolean(self, section_id, key):
        # type: (Text, Text) -> Optional[bool]
        pass

    @typing.overload
    def _getboolean(self, section_id, key, default):
        # type: (Text, Text, None) -> Optional[bool]
        pass

    def _getboolean(self, section_id, key, default=None):
        # type: (Text, Text, Optional[bool]) -> Optional[bool]
        if self.parser.has_option(section_id, key):
            return self.parser.getboolean(section_id, key)
        return default

    @typing.overload
    def _getint(self, section_id, key, default):
        # type: (Text, Text, None) -> Optional[int]
        pass

    @typing.overload
    def _getint(self, section_id, key):
        # type: (Text, Text) -> Optional[int]
        pass

    @typing.overload
    def _getint(self, section_id, key, default):
        # type: (Text, Text, int) -> int
        pass

    def _getint(self, section_id, key, default=None):
        # type: (Text, Text, Optional[int]) -> Optional[int]
        if self.parser.has_option(section_id, key):
            return self.parser.getint(section_id, key)
        return default

    @typing.overload
    def _get(self, section_id, key, default):
        # type: (Text, Text, None) -> Optional[Text]
        pass

    @typing.overload
    def _get(self, section_id, key):
        # type: (Text, Text) -> Optional[Text]
        pass

    @typing.overload
    def _get(self, section_id, key, default):
        # type: (Text, Text, Text) -> Text
        pass

    def _get(self, section_id, key, default=None):
        # type: (Text, Text, Optional[Text]) -> Optional[Text]
        if self.parser.has_option(section_id, key):
            return self.parser.get(section_id, key)
        return default

```
Tokens:
Raw