BranchesTags

Repository files navigation

pigdo - Parallel Implementation of Jigsaw Download

Introduction

pigdo is a program for reconstructing files that have been distributed in jigdo format. For more information about the original jigdo project, see:

http://atterer.org/jigdo/

The primary motivation behind pigdo is to provide a jigdo download client that is more efficient than the existing "jigdo-lite" and "jigit" jigdo download clients in space and in time:

  • Pigdo is more space-efficient than the existing jigdo download clients because it writes downloaded data directly to the output file, rather than downloading them to intermediate files which are then assembled into the output file.
  • This also makes pigdo more time-efficient, as it only needs to write the data once, rather than writing it once to save it to an intermediate file, then again to save it to the reassembled target file.
  • Pigdo is also more time-efficient than the existing clients because it can download multiple files simultaneously (hence "parallel" in its name).
  • This also makes pigdo more bandwidth-efficient as far as mirrors hosting the component files are concerned, because it supports downloading from multiple different mirrors, spreading the load across them. Some of the literature around jigdo seems to imply that being kinder to download mirrors is one of the advantages of downloading files via jigdo, yet there do not appear to be any existing jigdo clients that download files from more than one mirror at a time, which means that an individual download server is still responsible for servicing the entirety of a jigdo download, which doesn't seem much kinder than just downloading a single large file, except perhaps for the lightened storage burden of not having to keep a copy of it.

The name of the project is inspired by, but does not follow the same form as, the pigz project (and to a lesser extent, pixz). It also makes the author think of pigs with fancy hairstyles, which is a pretty cute thing to think about.

Building

Pigdo has dependencies upon:

  • libcurl, for fetching files over the network
  • zlib and libbz2, for decompressing bzip2, zlib, and gzip streams
  • POSIX Threads
  • Doxygen, for generating source code documentation (optional)
  • GNU Autotools (including the Autoconf Archive), if building from git

If any of these dependencies (apart from Autotools if you are building from a tarball, or Doxygen) are missing, pigdo may still build successfully, but might be limited in functionality to the point that it is unable to process .jigdo files.

The standard GNU Autotools workflow will build and install pigdo from the source tarball, i.e.:

  1. ./configure
  2. make
  3. make install

The install step is optional: the pigdo executable may be run directly from the source directory once it is built.

Note that the ./configure script is not checked into the git repository; the standard autotools workflow for regenerating ./configure is needed, e.g. autoreconf -i before ./configure (make sure you have the macros from the Autoconf Archive installed).

Usage

Pigdo takes, at a minimum, a single argument: a path to a .jigdo file. This may be located on your filesystem, or it may be a URI to a remote location. In the absence of any other arguments, pigdo will get the locations of the .template file and the output file, and the locations to search for matching files from the .jigdo file. These values can be supplemented or overridden using optional command line arguments.

For more detail on the individual command line options, run pigdo without any arguments to print a help message.

Documentation

Currently, the only documentation for pigdo is this README file and the source code. The source is commented in a Doxygen-compatible style, and documentation may be generated from the source code using Doxygen by running doxygen from the source directory.

Copying

You are free to use, study, modify, and redistribute pigdo under the terms of version 2 of the GNU General Public License. See the "COPYING" file for the full text of the GPLv2.

TODO

Pigdo is a work in progress, and while it is likely to work for many .jigdo files, if not most .jigdo files, there are several known unimplemented features and known bugs, and there are likely to be several unknown bugs as well.

Missing features include, but are not limited to:

  • Several features documented as being part of the .jigdo file format are not handled correctly; for example, quoting and character escapes and comments, specifying multiple possible paths for resolving matched files in the .jigdo file, and handling local and remote paths in places where pigdo currently only supports remote and local paths, respectively.
  • Some fields that are part of the .jigdo file format are ignored.
  • Pigdo is intended to allow caching downloaded files locally, in addition to assembling them directly into the target output file.
  • Pigdo was originally conceived as a standalone program, but much of its functionality is in the process of being split out into a library called libigdo, which will hopefully eventually export a sensible API for assembling files from .jigdo and .template files.

About

parallel implementation of jigsaw download

Resources

Readme
License
Activity

Stars

1 star

Watchers

1 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
pigdo - Parallel Implementation of Jigsaw Download
Introduction
pigdo is a program for reconstructing files that have been distributed in jigdo
format. For more information about the original jigdo project, see:
http://atterer.org/jigdo/
The primary motivation behind pigdo is to provide a jigdo download client that
is more efficient than the existing "jigdo-lite" and "jigit" jigdo download
clients in space and in time:
  • Pigdo is more space-efficient than the existing jigdo download clients because
it writes downloaded data directly to the output file, rather than downloading
them to intermediate files which are then assembled into the output file.
  • This also makes pigdo more time-efficient, as it only needs to write the data
once, rather than writing it once to save it to an intermediate file, then
again to save it to the reassembled target file.
  • Pigdo is also more time-efficient than the existing clients because it can
download multiple files simultaneously (hence "parallel" in its name).
  • This also makes pigdo more bandwidth-efficient as far as mirrors hosting the
component files are concerned, because it supports downloading from multiple
different mirrors, spreading the load across them. Some of the literature
around jigdo seems to imply that being kinder to download mirrors is one of
the advantages of downloading files via jigdo, yet there do not appear to be
any existing jigdo clients that download files from more than one mirror at a
time, which means that an individual download server is still responsible for
servicing the entirety of a jigdo download, which doesn't seem much kinder
than just downloading a single large file, except perhaps for the lightened
storage burden of not having to keep a copy of it.
The name of the project is inspired by, but does not follow the same form as,
the pigz project (and to a lesser extent, pixz). It also makes the author think
of pigs with fancy hairstyles, which is a pretty cute thing to think about.
Building
Pigdo has dependencies upon:
  • libcurl, for fetching files over the network
  • zlib and libbz2, for decompressing bzip2, zlib, and gzip streams
  • POSIX Threads
  • Doxygen, for generating source code documentation (optional)
  • GNU Autotools (including the Autoconf Archive), if building from git
If any of these dependencies (apart from Autotools if you are building from a
tarball, or Doxygen) are missing, pigdo may still build successfully, but might
be limited in functionality to the point that it is unable to process .jigdo
files.
The standard GNU Autotools workflow will build and install pigdo from the source
tarball, i.e.:
  1. ./configure
  2. make
  3. make install
The install step is optional: the pigdo executable may be run directly from the
source directory once it is built.
Note that the ./configure script is not checked into the git repository; the
standard autotools workflow for regenerating ./configure is needed, e.g.
autoreconf -i before ./configure (make sure you have the macros from the
Autoconf Archive installed).
Usage
Pigdo takes, at a minimum, a single argument: a path to a .jigdo file. This may
be located on your filesystem, or it may be a URI to a remote location. In the
absence of any other arguments, pigdo will get the locations of the .template
file and the output file, and the locations to search for matching files from
the .jigdo file. These values can be supplemented or overridden using optional
command line arguments.
For more detail on the individual command line options, run pigdo without any
arguments to print a help message.
Documentation
Currently, the only documentation for pigdo is this README file and the source
code. The source is commented in a Doxygen-compatible style, and documentation
may be generated from the source code using Doxygen by running doxygen from the
source directory.
Copying
You are free to use, study, modify, and redistribute pigdo under the terms of
version 2 of the GNU General Public License. See the "COPYING" file for the full
text of the GPLv2.
TODO
Pigdo is a work in progress, and while it is likely to work for many .jigdo
files, if not most .jigdo files, there are several known unimplemented features
and known bugs, and there are likely to be several unknown bugs as well.
Missing features include, but are not limited to:
  • Several features documented as being part of the .jigdo file format are not
handled correctly; for example, quoting and character escapes and comments,
specifying multiple possible paths for resolving matched files in the .jigdo
file, and handling local and remote paths in places where pigdo currently only
supports remote and local paths, respectively.
  • Some fields that are part of the .jigdo file format are ignored.
  • Pigdo is intended to allow caching downloaded files locally, in addition to
assembling them directly into the target output file.
  • Pigdo was originally conceived as a standalone program, but much of its
functionality is in the process of being split out into a library called
libigdo, which will hopefully eventually export a sensible API for assembling
files from .jigdo and .template files.
About
parallel implementation of jigsaw download
Resources
Readme
License
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
pigdo - Parallel Implementation of Jigsaw Download
Introduction
pigdo is a program for reconstructing files that have been distributed in jigdo
format. For more information about the original jigdo project, see:
http://atterer.org/jigdo/
The primary motivation behind pigdo is to provide a jigdo download client that
is more efficient than the existing "jigdo-lite" and "jigit" jigdo download
clients in space and in time:
  • Pigdo is more space-efficient than the existing jigdo download clients because
it writes downloaded data directly to the output file, rather than downloading
them to intermediate files which are then assembled into the output file.
  • This also makes pigdo more time-efficient, as it only needs to write the data
once, rather than writing it once to save it to an intermediate file, then
again to save it to the reassembled target file.
  • Pigdo is also more time-efficient than the existing clients because it can
download multiple files simultaneously (hence "parallel" in its name).
  • This also makes pigdo more bandwidth-efficient as far as mirrors hosting the
component files are concerned, because it supports downloading from multiple
different mirrors, spreading the load across them. Some of the literature
around jigdo seems to imply that being kinder to download mirrors is one of
the advantages of downloading files via jigdo, yet there do not appear to be
any existing jigdo clients that download files from more than one mirror at a
time, which means that an individual download server is still responsible for
servicing the entirety of a jigdo download, which doesn't seem much kinder
than just downloading a single large file, except perhaps for the lightened
storage burden of not having to keep a copy of it.
The name of the project is inspired by, but does not follow the same form as,
the pigz project (and to a lesser extent, pixz). It also makes the author think
of pigs with fancy hairstyles, which is a pretty cute thing to think about.
Building
Pigdo has dependencies upon:
  • libcurl, for fetching files over the network
  • zlib and libbz2, for decompressing bzip2, zlib, and gzip streams
  • POSIX Threads
  • Doxygen, for generating source code documentation (optional)
  • GNU Autotools (including the Autoconf Archive), if building from git
If any of these dependencies (apart from Autotools if you are building from a
tarball, or Doxygen) are missing, pigdo may still build successfully, but might
be limited in functionality to the point that it is unable to process .jigdo
files.
The standard GNU Autotools workflow will build and install pigdo from the source
tarball, i.e.:
  1. ./configure
  2. make
  3. make install
The install step is optional: the pigdo executable may be run directly from the
source directory once it is built.
Note that the ./configure script is not checked into the git repository; the
standard autotools workflow for regenerating ./configure is needed, e.g.
autoreconf -i before ./configure (make sure you have the macros from the
Autoconf Archive installed).
Usage
Pigdo takes, at a minimum, a single argument: a path to a .jigdo file. This may
be located on your filesystem, or it may be a URI to a remote location. In the
absence of any other arguments, pigdo will get the locations of the .template
file and the output file, and the locations to search for matching files from
the .jigdo file. These values can be supplemented or overridden using optional
command line arguments.
For more detail on the individual command line options, run pigdo without any
arguments to print a help message.
Documentation
Currently, the only documentation for pigdo is this README file and the source
code. The source is commented in a Doxygen-compatible style, and documentation
may be generated from the source code using Doxygen by running doxygen from the
source directory.
Copying
You are free to use, study, modify, and redistribute pigdo under the terms of
version 2 of the GNU General Public License. See the "COPYING" file for the full
text of the GPLv2.
TODO
Pigdo is a work in progress, and while it is likely to work for many .jigdo
files, if not most .jigdo files, there are several known unimplemented features
and known bugs, and there are likely to be several unknown bugs as well.
Missing features include, but are not limited to:
  • Several features documented as being part of the .jigdo file format are not
handled correctly; for example, quoting and character escapes and comments,
specifying multiple possible paths for resolving matched files in the .jigdo
file, and handling local and remote paths in places where pigdo currently only
supports remote and local paths, respectively.
  • Some fields that are part of the .jigdo file format are ignored.
  • Pigdo is intended to allow caching downloaded files locally, in addition to
assembling them directly into the target output file.
  • Pigdo was originally conceived as a standalone program, but much of its
functionality is in the process of being split out into a library called
libigdo, which will hopefully eventually export a sensible API for assembling
files from .jigdo and .template files.
About
parallel implementation of jigsaw download
Resources
Readme
License
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
pigdo - Parallel Implementation of Jigsaw Download
Introduction
pigdo is a program for reconstructing files that have been distributed in jigdo
format. For more information about the original jigdo project, see:
http://atterer.org/jigdo/
The primary motivation behind pigdo is to provide a jigdo download client that
is more efficient than the existing "jigdo-lite" and "jigit" jigdo download
clients in space and in time:
  • Pigdo is more space-efficient than the existing jigdo download clients because
it writes downloaded data directly to the output file, rather than downloading
them to intermediate files which are then assembled into the output file.
  • This also makes pigdo more time-efficient, as it only needs to write the data
once, rather than writing it once to save it to an intermediate file, then
again to save it to the reassembled target file.
  • Pigdo is also more time-efficient than the existing clients because it can
download multiple files simultaneously (hence "parallel" in its name).
  • This also makes pigdo more bandwidth-efficient as far as mirrors hosting the
component files are concerned, because it supports downloading from multiple
different mirrors, spreading the load across them. Some of the literature
around jigdo seems to imply that being kinder to download mirrors is one of
the advantages of downloading files via jigdo, yet there do not appear to be
any existing jigdo clients that download files from more than one mirror at a
time, which means that an individual download server is still responsible for
servicing the entirety of a jigdo download, which doesn't seem much kinder
than just downloading a single large file, except perhaps for the lightened
storage burden of not having to keep a copy of it.
The name of the project is inspired by, but does not follow the same form as,
the pigz project (and to a lesser extent, pixz). It also makes the author think
of pigs with fancy hairstyles, which is a pretty cute thing to think about.
Building
Pigdo has dependencies upon:
  • libcurl, for fetching files over the network
  • zlib and libbz2, for decompressing bzip2, zlib, and gzip streams
  • POSIX Threads
  • Doxygen, for generating source code documentation (optional)
  • GNU Autotools (including the Autoconf Archive), if building from git
If any of these dependencies (apart from Autotools if you are building from a
tarball, or Doxygen) are missing, pigdo may still build successfully, but might
be limited in functionality to the point that it is unable to process .jigdo
files.
The standard GNU Autotools workflow will build and install pigdo from the source
tarball, i.e.:
  1. ./configure
  2. make
  3. make install
The install step is optional: the pigdo executable may be run directly from the
source directory once it is built.
Note that the ./configure script is not checked into the git repository; the
standard autotools workflow for regenerating ./configure is needed, e.g.
autoreconf -i before ./configure (make sure you have the macros from the
Autoconf Archive installed).
Usage
Pigdo takes, at a minimum, a single argument: a path to a .jigdo file. This may
be located on your filesystem, or it may be a URI to a remote location. In the
absence of any other arguments, pigdo will get the locations of the .template
file and the output file, and the locations to search for matching files from
the .jigdo file. These values can be supplemented or overridden using optional
command line arguments.
For more detail on the individual command line options, run pigdo without any
arguments to print a help message.
Documentation
Currently, the only documentation for pigdo is this README file and the source
code. The source is commented in a Doxygen-compatible style, and documentation
may be generated from the source code using Doxygen by running doxygen from the
source directory.
Copying
You are free to use, study, modify, and redistribute pigdo under the terms of
version 2 of the GNU General Public License. See the "COPYING" file for the full
text of the GPLv2.
TODO
Pigdo is a work in progress, and while it is likely to work for many .jigdo
files, if not most .jigdo files, there are several known unimplemented features
and known bugs, and there are likely to be several unknown bugs as well.
Missing features include, but are not limited to:
  • Several features documented as being part of the .jigdo file format are not
handled correctly; for example, quoting and character escapes and comments,
specifying multiple possible paths for resolving matched files in the .jigdo
file, and handling local and remote paths in places where pigdo currently only
supports remote and local paths, respectively.
  • Some fields that are part of the .jigdo file format are ignored.
  • Pigdo is intended to allow caching downloaded files locally, in addition to
assembling them directly into the target output file.
  • Pigdo was originally conceived as a standalone program, but much of its
functionality is in the process of being split out into a library called
libigdo, which will hopefully eventually export a sensible API for assembling
files from .jigdo and .template files.
About
parallel implementation of jigsaw download
Resources
Readme
License
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
pigdo - Parallel Implementation of Jigsaw Download
Introduction
pigdo is a program for reconstructing files that have been distributed in jigdo
format. For more information about the original jigdo project, see:
http://atterer.org/jigdo/
The primary motivation behind pigdo is to provide a jigdo download client that
is more efficient than the existing "jigdo-lite" and "jigit" jigdo download
clients in space and in time:
  • Pigdo is more space-efficient than the existing jigdo download clients because
it writes downloaded data directly to the output file, rather than downloading
them to intermediate files which are then assembled into the output file.
  • This also makes pigdo more time-efficient, as it only needs to write the data
once, rather than writing it once to save it to an intermediate file, then
again to save it to the reassembled target file.
  • Pigdo is also more time-efficient than the existing clients because it can
download multiple files simultaneously (hence "parallel" in its name).
  • This also makes pigdo more bandwidth-efficient as far as mirrors hosting the
component files are concerned, because it supports downloading from multiple
different mirrors, spreading the load across them. Some of the literature
around jigdo seems to imply that being kinder to download mirrors is one of
the advantages of downloading files via jigdo, yet there do not appear to be
any existing jigdo clients that download files from more than one mirror at a
time, which means that an individual download server is still responsible for
servicing the entirety of a jigdo download, which doesn't seem much kinder
than just downloading a single large file, except perhaps for the lightened
storage burden of not having to keep a copy of it.
The name of the project is inspired by, but does not follow the same form as,
the pigz project (and to a lesser extent, pixz). It also makes the author think
of pigs with fancy hairstyles, which is a pretty cute thing to think about.
Building
Pigdo has dependencies upon:
  • libcurl, for fetching files over the network
  • zlib and libbz2, for decompressing bzip2, zlib, and gzip streams
  • POSIX Threads
  • Doxygen, for generating source code documentation (optional)
  • GNU Autotools (including the Autoconf Archive), if building from git
If any of these dependencies (apart from Autotools if you are building from a
tarball, or Doxygen) are missing, pigdo may still build successfully, but might
be limited in functionality to the point that it is unable to process .jigdo
files.
The standard GNU Autotools workflow will build and install pigdo from the source
tarball, i.e.:
  1. ./configure
  2. make
  3. make install
The install step is optional: the pigdo executable may be run directly from the
source directory once it is built.
Note that the ./configure script is not checked into the git repository; the
standard autotools workflow for regenerating ./configure is needed, e.g.
autoreconf -i before ./configure (make sure you have the macros from the
Autoconf Archive installed).
Usage
Pigdo takes, at a minimum, a single argument: a path to a .jigdo file. This may
be located on your filesystem, or it may be a URI to a remote location. In the
absence of any other arguments, pigdo will get the locations of the .template
file and the output file, and the locations to search for matching files from
the .jigdo file. These values can be supplemented or overridden using optional
command line arguments.
For more detail on the individual command line options, run pigdo without any
arguments to print a help message.
Documentation
Currently, the only documentation for pigdo is this README file and the source
code. The source is commented in a Doxygen-compatible style, and documentation
may be generated from the source code using Doxygen by running doxygen from the
source directory.
Copying
You are free to use, study, modify, and redistribute pigdo under the terms of
version 2 of the GNU General Public License. See the "COPYING" file for the full
text of the GPLv2.
TODO
Pigdo is a work in progress, and while it is likely to work for many .jigdo
files, if not most .jigdo files, there are several known unimplemented features
and known bugs, and there are likely to be several unknown bugs as well.
Missing features include, but are not limited to:
  • Several features documented as being part of the .jigdo file format are not
handled correctly; for example, quoting and character escapes and comments,
specifying multiple possible paths for resolving matched files in the .jigdo
file, and handling local and remote paths in places where pigdo currently only
supports remote and local paths, respectively.
  • Some fields that are part of the .jigdo file format are ignored.
  • Pigdo is intended to allow caching downloaded files locally, in addition to
assembling them directly into the target output file.
  • Pigdo was originally conceived as a standalone program, but much of its
functionality is in the process of being split out into a library called
libigdo, which will hopefully eventually export a sensible API for assembling
files from .jigdo and .template files.
About
parallel implementation of jigsaw download
Resources
Readme
License
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
pigdo - Parallel Implementation of Jigsaw Download
Introduction
pigdo is a program for reconstructing files that have been distributed in jigdo
format. For more information about the original jigdo project, see:
http://atterer.org/jigdo/
The primary motivation behind pigdo is to provide a jigdo download client that
is more efficient than the existing "jigdo-lite" and "jigit" jigdo download
clients in space and in time:
  • Pigdo is more space-efficient than the existing jigdo download clients because
it writes downloaded data directly to the output file, rather than downloading
them to intermediate files which are then assembled into the output file.
  • This also makes pigdo more time-efficient, as it only needs to write the data
once, rather than writing it once to save it to an intermediate file, then
again to save it to the reassembled target file.
  • Pigdo is also more time-efficient than the existing clients because it can
download multiple files simultaneously (hence "parallel" in its name).
  • This also makes pigdo more bandwidth-efficient as far as mirrors hosting the
component files are concerned, because it supports downloading from multiple
different mirrors, spreading the load across them. Some of the literature
around jigdo seems to imply that being kinder to download mirrors is one of
the advantages of downloading files via jigdo, yet there do not appear to be
any existing jigdo clients that download files from more than one mirror at a
time, which means that an individual download server is still responsible for
servicing the entirety of a jigdo download, which doesn't seem much kinder
than just downloading a single large file, except perhaps for the lightened
storage burden of not having to keep a copy of it.
The name of the project is inspired by, but does not follow the same form as,
the pigz project (and to a lesser extent, pixz). It also makes the author think
of pigs with fancy hairstyles, which is a pretty cute thing to think about.
Building
Pigdo has dependencies upon:
  • libcurl, for fetching files over the network
  • zlib and libbz2, for decompressing bzip2, zlib, and gzip streams
  • POSIX Threads
  • Doxygen, for generating source code documentation (optional)
  • GNU Autotools (including the Autoconf Archive), if building from git
If any of these dependencies (apart from Autotools if you are building from a
tarball, or Doxygen) are missing, pigdo may still build successfully, but might
be limited in functionality to the point that it is unable to process .jigdo
files.
The standard GNU Autotools workflow will build and install pigdo from the source
tarball, i.e.:
  1. ./configure
  2. make
  3. make install
The install step is optional: the pigdo executable may be run directly from the
source directory once it is built.
Note that the ./configure script is not checked into the git repository; the
standard autotools workflow for regenerating ./configure is needed, e.g.
autoreconf -i before ./configure (make sure you have the macros from the
Autoconf Archive installed).
Usage
Pigdo takes, at a minimum, a single argument: a path to a .jigdo file. This may
be located on your filesystem, or it may be a URI to a remote location. In the
absence of any other arguments, pigdo will get the locations of the .template
file and the output file, and the locations to search for matching files from
the .jigdo file. These values can be supplemented or overridden using optional
command line arguments.
For more detail on the individual command line options, run pigdo without any
arguments to print a help message.
Documentation
Currently, the only documentation for pigdo is this README file and the source
code. The source is commented in a Doxygen-compatible style, and documentation
may be generated from the source code using Doxygen by running doxygen from the
source directory.
Copying
You are free to use, study, modify, and redistribute pigdo under the terms of
version 2 of the GNU General Public License. See the "COPYING" file for the full
text of the GPLv2.
TODO
Pigdo is a work in progress, and while it is likely to work for many .jigdo
files, if not most .jigdo files, there are several known unimplemented features
and known bugs, and there are likely to be several unknown bugs as well.
Missing features include, but are not limited to:
  • Several features documented as being part of the .jigdo file format are not
handled correctly; for example, quoting and character escapes and comments,
specifying multiple possible paths for resolving matched files in the .jigdo
file, and handling local and remote paths in places where pigdo currently only
supports remote and local paths, respectively.
  • Some fields that are part of the .jigdo file format are ignored.
  • Pigdo is intended to allow caching downloaded files locally, in addition to
assembling them directly into the target output file.
  • Pigdo was originally conceived as a standalone program, but much of its
functionality is in the process of being split out into a library called
libigdo, which will hopefully eventually export a sensible API for assembling
files from .jigdo and .template files.
About
parallel implementation of jigsaw download
Resources
Readme
License
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
pigdo - Parallel Implementation of Jigsaw Download
Introduction
pigdo is a program for reconstructing files that have been distributed in jigdo
format. For more information about the original jigdo project, see:
http://atterer.org/jigdo/
The primary motivation behind pigdo is to provide a jigdo download client that
is more efficient than the existing "jigdo-lite" and "jigit" jigdo download
clients in space and in time:
  • Pigdo is more space-efficient than the existing jigdo download clients because
it writes downloaded data directly to the output file, rather than downloading
them to intermediate files which are then assembled into the output file.
  • This also makes pigdo more time-efficient, as it only needs to write the data
once, rather than writing it once to save it to an intermediate file, then
again to save it to the reassembled target file.
  • Pigdo is also more time-efficient than the existing clients because it can
download multiple files simultaneously (hence "parallel" in its name).
  • This also makes pigdo more bandwidth-efficient as far as mirrors hosting the
component files are concerned, because it supports downloading from multiple
different mirrors, spreading the load across them. Some of the literature
around jigdo seems to imply that being kinder to download mirrors is one of
the advantages of downloading files via jigdo, yet there do not appear to be
any existing jigdo clients that download files from more than one mirror at a
time, which means that an individual download server is still responsible for
servicing the entirety of a jigdo download, which doesn't seem much kinder
than just downloading a single large file, except perhaps for the lightened
storage burden of not having to keep a copy of it.
The name of the project is inspired by, but does not follow the same form as,
the pigz project (and to a lesser extent, pixz). It also makes the author think
of pigs with fancy hairstyles, which is a pretty cute thing to think about.
Building
Pigdo has dependencies upon:
  • libcurl, for fetching files over the network
  • zlib and libbz2, for decompressing bzip2, zlib, and gzip streams
  • POSIX Threads
  • Doxygen, for generating source code documentation (optional)
  • GNU Autotools (including the Autoconf Archive), if building from git
If any of these dependencies (apart from Autotools if you are building from a
tarball, or Doxygen) are missing, pigdo may still build successfully, but might
be limited in functionality to the point that it is unable to process .jigdo
files.
The standard GNU Autotools workflow will build and install pigdo from the source
tarball, i.e.:
  1. ./configure
  2. make
  3. make install
The install step is optional: the pigdo executable may be run directly from the
source directory once it is built.
Note that the ./configure script is not checked into the git repository; the
standard autotools workflow for regenerating ./configure is needed, e.g.
autoreconf -i before ./configure (make sure you have the macros from the
Autoconf Archive installed).
Usage
Pigdo takes, at a minimum, a single argument: a path to a .jigdo file. This may
be located on your filesystem, or it may be a URI to a remote location. In the
absence of any other arguments, pigdo will get the locations of the .template
file and the output file, and the locations to search for matching files from
the .jigdo file. These values can be supplemented or overridden using optional
command line arguments.
For more detail on the individual command line options, run pigdo without any
arguments to print a help message.
Documentation
Currently, the only documentation for pigdo is this README file and the source
code. The source is commented in a Doxygen-compatible style, and documentation
may be generated from the source code using Doxygen by running doxygen from the
source directory.
Copying
You are free to use, study, modify, and redistribute pigdo under the terms of
version 2 of the GNU General Public License. See the "COPYING" file for the full
text of the GPLv2.
TODO
Pigdo is a work in progress, and while it is likely to work for many .jigdo
files, if not most .jigdo files, there are several known unimplemented features
and known bugs, and there are likely to be several unknown bugs as well.
Missing features include, but are not limited to:
  • Several features documented as being part of the .jigdo file format are not
handled correctly; for example, quoting and character escapes and comments,
specifying multiple possible paths for resolving matched files in the .jigdo
file, and handling local and remote paths in places where pigdo currently only
supports remote and local paths, respectively.
  • Some fields that are part of the .jigdo file format are ignored.
  • Pigdo is intended to allow caching downloaded files locally, in addition to
assembling them directly into the target output file.
  • Pigdo was originally conceived as a standalone program, but much of its
functionality is in the process of being split out into a library called
libigdo, which will hopefully eventually export a sensible API for assembling
files from .jigdo and .template files.
About
parallel implementation of jigsaw download
Resources
Readme
License
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
pigdo - Parallel Implementation of Jigsaw Download
Introduction
pigdo is a program for reconstructing files that have been distributed in jigdo
format. For more information about the original jigdo project, see:
http://atterer.org/jigdo/
The primary motivation behind pigdo is to provide a jigdo download client that
is more efficient than the existing "jigdo-lite" and "jigit" jigdo download
clients in space and in time:
  • Pigdo is more space-efficient than the existing jigdo download clients because
it writes downloaded data directly to the output file, rather than downloading
them to intermediate files which are then assembled into the output file.
  • This also makes pigdo more time-efficient, as it only needs to write the data
once, rather than writing it once to save it to an intermediate file, then
again to save it to the reassembled target file.
  • Pigdo is also more time-efficient than the existing clients because it can
download multiple files simultaneously (hence "parallel" in its name).
  • This also makes pigdo more bandwidth-efficient as far as mirrors hosting the
component files are concerned, because it supports downloading from multiple
different mirrors, spreading the load across them. Some of the literature
around jigdo seems to imply that being kinder to download mirrors is one of
the advantages of downloading files via jigdo, yet there do not appear to be
any existing jigdo clients that download files from more than one mirror at a
time, which means that an individual download server is still responsible for
servicing the entirety of a jigdo download, which doesn't seem much kinder
than just downloading a single large file, except perhaps for the lightened
storage burden of not having to keep a copy of it.
The name of the project is inspired by, but does not follow the same form as,
the pigz project (and to a lesser extent, pixz). It also makes the author think
of pigs with fancy hairstyles, which is a pretty cute thing to think about.
Building
Pigdo has dependencies upon:
  • libcurl, for fetching files over the network
  • zlib and libbz2, for decompressing bzip2, zlib, and gzip streams
  • POSIX Threads
  • Doxygen, for generating source code documentation (optional)
  • GNU Autotools (including the Autoconf Archive), if building from git
If any of these dependencies (apart from Autotools if you are building from a
tarball, or Doxygen) are missing, pigdo may still build successfully, but might
be limited in functionality to the point that it is unable to process .jigdo
files.
The standard GNU Autotools workflow will build and install pigdo from the source
tarball, i.e.:
  1. ./configure
  2. make
  3. make install
The install step is optional: the pigdo executable may be run directly from the
source directory once it is built.
Note that the ./configure script is not checked into the git repository; the
standard autotools workflow for regenerating ./configure is needed, e.g.
autoreconf -i before ./configure (make sure you have the macros from the
Autoconf Archive installed).
Usage
Pigdo takes, at a minimum, a single argument: a path to a .jigdo file. This may
be located on your filesystem, or it may be a URI to a remote location. In the
absence of any other arguments, pigdo will get the locations of the .template
file and the output file, and the locations to search for matching files from
the .jigdo file. These values can be supplemented or overridden using optional
command line arguments.
For more detail on the individual command line options, run pigdo without any
arguments to print a help message.
Documentation
Currently, the only documentation for pigdo is this README file and the source
code. The source is commented in a Doxygen-compatible style, and documentation
may be generated from the source code using Doxygen by running doxygen from the
source directory.
Copying
You are free to use, study, modify, and redistribute pigdo under the terms of
version 2 of the GNU General Public License. See the "COPYING" file for the full
text of the GPLv2.
TODO
Pigdo is a work in progress, and while it is likely to work for many .jigdo
files, if not most .jigdo files, there are several known unimplemented features
and known bugs, and there are likely to be several unknown bugs as well.
Missing features include, but are not limited to:
  • Several features documented as being part of the .jigdo file format are not
handled correctly; for example, quoting and character escapes and comments,
specifying multiple possible paths for resolving matched files in the .jigdo
file, and handling local and remote paths in places where pigdo currently only
supports remote and local paths, respectively.
  • Some fields that are part of the .jigdo file format are ignored.
  • Pigdo is intended to allow caching downloaded files locally, in addition to
assembling them directly into the target output file.
  • Pigdo was originally conceived as a standalone program, but much of its
functionality is in the process of being split out into a library called
libigdo, which will hopefully eventually export a sensible API for assembling
files from .jigdo and .template files.
About
parallel implementation of jigsaw download
Resources
Readme
License
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages