A Dark theme for the PiHole admin page. (Now FTL compatible)

1. open a terminal (or SSH if you’re remoting in) ( Ctrl + Alt + T )
2. Type: cd /var/www/html/
3. Type: sudo wget https://raw.githubusercontent.com/lkd70/PiHole-Dark/master/install.sh
4. Type: sudo chmod +x install.sh
5. Type: sudo ./install.sh
6. Follow the onscreen instructions!

Not a fan of the style? Sorry to hear, please feel free to leave some feedback on the Official Thread. Sadly this theme isn’t for everyone, so here’s a simple method to restore the origional beauty of PiHole:

1. open a terminal (or SSH if you’re remoting in) ( Ctrl + Alt + T )
2. Type: cd /var/www/html/admin/
3. Type git reset --hard
4. Go leave some feedback so we know what you didn’t like!

Something you’d like to see? Or maybe there’s an incompatibility with a newer version of pi-hole? Please open an issue or make a pull request!

First of all, I’d like to say sorry for your eyes, I’m sure they hurt the way mine did upon first seeing that sight.
Let’s look at two possible solutions to this.

You can easily replace the ugly image in /var/www/html/admin/img/boxed-bg.jpg with a pretty dark one.

You can change to a wide-view from the admin website by navigating to: Settings -> API / Web Interface -> Web interface settings and un-checking the Use boxed layout option.

Refunds cost $1 each, please contact me at totallylegitemail@contact.com

(Have you tried refreshing your browsers cache? Chances are it’s still grabbing the old files)

All credits to the original creators of these files, I am merely an editor.
All credits to the Pi-Hole Team for their great platform.

Do follow the individual licenses of these files as supplied by the authors.

Inspired by this thread.

Thanks to deathbybandaid for the new easy install method!

Graphsurge is a new system for performing analytical computations on multiple snapshots or views of large-scale static property graphs. Graphsurge allows users to create view collections, a set of related views of a graph created by applying filter predicates on node and edge properties, and run analytical computations on all the views of a collection efficiently.

Graphsurge is built on top of Timely Dataflow and Differential Dataflow, which provides two huge benefits:

• Differential Dataflow can incrementally maintain the results for any general computation, including cyclic or iterative computations (which include many graph algorithms such as Connected Components. Analytical computations in Graphsurge are expressed using Differential operators and enables reusing computation results across the views of a collection instead of running computations from scratch on each view. This results in huge savings on the total runtime.
• We use the Timely execution engine to seamlessly scale both the materialization of view collections and running analytical computations to a distributed environment, similar to using other execution frameworks such as Spark or Flink.

Graphsurge stores view collections using a form of delta encoding, where the data for a view GV_i represent its difference with the previous view GV_i-1. This representation can also be directly used as inputs to Differential Dataflow computations.

In general, the runtime of a black-box differential computation (such as the user-defined computations in Graphsurge) is correlated with the total number of diffs of a view collection. Graphsurge enables 2 key optimizations based on this observation:

• Collection Ordering: The total number of diffs of a view collection depends on the order the views (similar views placed next to each other will generate less diffs) and we want to reorder a given set of views to get the lowest number of diffs. This Collection Ordering Problem is related to the Consecutive Block Minimization Problem, which is NP-Hard! Graphsurge solves this problem using a constant-factor approximation algorithm (resulting in up to 10x less diffs in our experiments).

• Adaptive Collection Splitting: Maintaining computation results unsurprisingly implies an overhead for Differential Dataflow, as it needs to check the entire history of a key to determine the effect of a new update. This overhead is especially large for cases where the number of diffs of a view are high, or for computations (like PageRank) which results in a large number of output changes even for small number of input updates. In such cases, it is faster to run the computation on a view from scratch instead of trying to reuse results from previous views.

  Graphsurge keeps track of the correlation between the number of the diffs and the actual computation time when running differentially and also when rerunning from scratch. It uses a linear regression model to adaptively decide at runtime to split the view collection at the point where rerunning from scratch is predicted to be faster than to continue running differentially.

More details on our techniques and experimental results can be found in our paper.

Graphsurge is written in Rust. To run the Graphsurge cli, download and build the binary:

$ git clone https://github.com/dsg-uwaterloo/graphsurge && cd graphsurge
$ cargo build --release
$ ./target/bin/graphsurge

graphsurge> SET THREADS 4 AND PROCESS_ID 0;

graphsurge> LOAD GRAPH WITH
    VERTICES FROM 'data/small_properties/vertices.txt' and
    EDGES FROM 'data/small_properties/edges.txt'
    COMMENT '#';

graphsurge> CREATE VIEW COLLECTION Years WHERE
    [year <= 2000 and u.country = 'canada' and v.country = 'canada'],
    [year <= 2005 and u.country = 'canada' and v.country = 'canada'],
    [year <= 2010 and u.country = 'canada' and v.country = 'canada'];

$ mkdir bfs_results

graphsurge> RUN COMPUTATION wcc ON COLLECTION Years SAVE RESULTS TO 'bfs_results';

To run Graphsurge on multiple machines, say on 2 hosts server1 and server2, start Graphsurge and set the process ids:

# On server1
graphsurge> SET THREADS 32 AND PROCESS_ID 0;

# On server2
graphsurge> SET THREADS 32 AND PROCESS_ID 1;

Then run the same queries on both of them. Make sure that server1 and server2 can access each other at the specified port.

graphsurge> LOAD GRAPH WITH
    VERTICES FROM 'data/small_properties/vertices.txt' and
    EDGES FROM 'data/small_properties/edges.txt'
    COMMENT '#';
graphsurge> CREATE VIEW COLLECTION Years WHERE
    [year <= 2000 and u.country = 'canada' and v.country = 'canada'],
    [year <= 2005 and u.country = 'canada' and v.country = 'canada'],
    [year <= 2010 and u.country = 'canada' and v.country = 'canada']
    HOSTS 'server1:9000' 'server2:9000';
graphsurge> RUN ARRANGED_DIFFERENTIAL COMPUTATION wcc on COLLECTION Years
    HOSTS 'server1:9000' 'server2:9000';

The same process can be repeated for additional hosts machines.

Graphsurge already has implementations for a set of common graph algorithms. New computations can be written using the Analytics Computation API. You can see examples of how to use the API for bfs and scc.

Check the experiments folder for examples on how to use Graphsurge.

Late 2014, I initiated an MQTT client library for Scala side project.
My purpose was to learn me some Akka while trying to deliver something potentially useful. I quickly
found the excellent scodec library to encode/decode MQTT protocol frames, making
this part of the work considerably easier, with a concise and very readable outcome.

More recently, while getting more and more interest in pure functional programming in Scala, in had the chance to see
this amazing talk on Skunk from @tpolecat. It’s about
building, from the ground up, a data access library for Postgres based on FS2 and… scodec.

I rushed to Skunk, which as been inspirational, and took the opportunity of the
lock-down days, around april 2020, to learn a lot about cats, cats effect
and of course FS2. I even found the integration between FS2 and scodec, scodec-stream,
to be utterly useful.

With all these tools at hand, and the book Practical-FP in Scala: A hands-on approach
on my desk, it has been quite (sic) easy to connect everything together and build this purely functional Scala MQTT
client library.

This library is build in the tagless final style in order to make it, as much as possible, IO monad agnostic for the
client code using it. It’s internals are nevertheless mainly build around FS2, cats effect typeclasses and concurrency
primitives.

It implements almost all the MQTT 3.1.1 protocol, managing (re)connections and in flight messages, and allows interacting
with a Mosquitto broker. It does not support MQTT 5 and, to tell the truth, this is not even envisioned!
Still, there’s work ahead:

• finer grained configuration (e. g. number of in flight messages)
• a proper documentation
• shame on me, far more test coverage /o\
• performance evaluation
• trying to consider Scala.js,
• …

For examples on how to use it, you can have a look at the local subscriber or the local publisher
code. Both are based on Cats Effect IO.

Artifacts are available at Sonatype OSS Repository Hosting service, even the SNAPSHOTS are automatically
built by GitHub Actions. To include the Sonatype repositories in your SBT build you should add,

resolvers ++= Seq(
    Resolver.sonatypeRepo("releases"),
    Resolver.sonatypeRepo("snapshots")
)

In case you want to easily give a try to this library, without the burden of adding resolvers, there is a release synced
to Maven Central. In this case just add,

scalaVersion := "3.3.1"

libraryDependencies ++= Seq(
    "net.sigusr" %% "fs2-mqtt" % "1.0.1"
)

Roughly speaking this library depends on:

• Scala of course, but not Scala.js even thought this should be fairly easy…
• Cats effect
• FS2
• scodec and scodec-stream
• Cats effects retry to manage connection attempts

It should work seamlessly with various compatible IO monads: Cats Effect IO
of course and ZIO as it supports cats effect typeclasses. Monix used to be supported as well, but
since version 1.0.0 and the migration to cats effect3.x, this is no more the case.

This work is licenced under an Apache Version 2.0 license

Active maintainer: Yuqian Hong

Initial maintainers: Jingyang Zhang, Yueqian Lin

More and more large multimodal models (LMMs) are being released from time to time, but the finetuning of these models is not always straightforward. This codebase aims to provide a unified, minimal structure for LMM finetuning. Key design ideas include:

• the components of the finetuning process (e.g., model loading, data collating) are abstracted, allowing one to easily integrate the latest LMMs into this codebase and finetune them with minimal effort;
• for all LMMs the 🤗huggingface’s official implementation is used, so that after finetuning one can do inference and everything else in the exact same way as earlier with the HF model;
• the codebase is kept as simple/lightweight as possible, so that it is easy to understand and modify.

The codebase is quite flexible. It supports the finetuning of various types of LMMs, including:

• 🌇 single image models: LLaVA-1.5, LLaVA-1.6/NeXT, Phi-3-Vision, Llama-3.2-Vision
• 📑 multiple/interleaved image models: Qwen-VL-Chat, Qwen2-VL-Instruct, LLaVA-NeXT-Interleave, Qwen2.5-VL-Instruct
• 🎥 video models: LLaVA-NeXT-Video
• 🚀 unified models: LLaVA-Onevision

See supported_models.md for the full list of supported models. For training strategy, 1) full-finetuning, 2) lora, and 3) q-lora are supported for the LLM component, while 1) full-finetuning and 2) lora are supported for the vision encoder/backbone.

• 2025/01/27: Qwen2.5 family is supported in the transformers-4.49.0.dev0 branch. At the moment you would need to install the latest transformers from github.
• 2024/12/16: Thanks to the contribution from lavinal712 (Yuqian), training with Llama-3.2-Vision is now supported. Also there is a useful script merge_lora_weights.py added.
• 2024/10/16: We added LLaVA-Onevision. See a caveat when using LLaVA-Onevision here. Also we updated the collators to stay in line with the new processing of LLaVA models in transformers.
• 2024/08/28: Finetuning with gradio webui interface is supported. Try python webui.py.
• 2024/07/30: Finetuning of vision encoder and projector is now supported.
• 2024/07/25: Several things are improved. We have 1) released a colab notebook demonstrating a full, successful training run with LLaVA-NeXT-Video-7B (happy to hear from people that they succeeded in their cases too); 2) supported having text-only samples in the training set (see this for one note).
• 2024/07/20: Initial release of the codebase. More models and optimizations are coming soon. Stay tuned!

# clone this repo
git clone https://github.com/zjysteven/lmms-finetune.git

# set up a conda environment
conda create -n lmms-finetune python=3.10 -y
conda activate lmms-finetune
## this will install the latest version of torch
## feel free to change it to a specific version
python -m pip install -r requirements.txt

## optionally install flash attention
python -m pip install --no-cache-dir --no-build-isolation flash-attn

A workable example training run (of LLaVA-NeXT-Video-7B) is showcased in this colab notebook, which is a good starting point to get a sense of how to use this codebase. The following sections provide a more detailed guide on how to finetune a model.

Supported models:
  Model ID                      : HuggingFace Path
  ------------------------------------------------
  llava-1.5-7b                  : llava-hf/llava-1.5-7b-hf
  llava-1.5-13b                 : llava-hf/llava-1.5-13b-hf
  llava-next-video-7b           : llava-hf/LLaVA-NeXT-Video-7B-hf
  llava-next-video-7b-32k       : llava-hf/LLaVA-NeXT-Video-7B-32K-hf
  llava-next-video-34b          : llava-hf/LLaVA-NeXT-Video-34B-hf
  llava-interleave-qwen-0.5b    : llava-hf/llava-interleave-qwen-0.5b-hf
  llava-interleave-qwen-7b      : llava-hf/llava-interleave-qwen-7b-hf
  llava-onevision-0.5b-ov       : llava-hf/llava-onevision-qwen2-0.5b-ov-hf
  llava-onevision-7b-ov         : llava-hf/llava-onevision-qwen2-7b-ov-hf
  llava-onevision-72b-ov        : llava-hf/llava-onevision-qwen2-72b-ov-hf
  qwen-vl-chat                  : Qwen/Qwen-VL-Chat
  phi3-v                        : microsoft/Phi-3-vision-128k-instruct
  qwen2-vl-2b-instruct          : Qwen/Qwen2-VL-2B-Instruct
  qwen2-vl-7b-instruct          : Qwen/Qwen2-VL-7B-Instruct
  llama-3.2-11b-vision-instruct : meta-llama/Llama-3.2-11B-Vision-Instruct
  llama-3.2-90b-vision-instruct : meta-llama/Llama-3.2-90B-Vision-Instruct

[
    {
        "system_prompt": "You are a helpful assistant.",
        "video": "path/to/video1.mp4",
        "conversations": [
            {
                "from": "human",
                "value": "<video>What is this video about?"
            },
            {
                "from": "gpt",
                "value": "This video shows a baby crying."
            },
        ]
    }
]

We want to thank the huggingface team for actively integrating newest models in the transformers library. Also, the example finetuning scripts (e.g., this, this, and this) made by HF staff, Niels Rogge and Raushan Turganbay, are very helpful and lay the foundation for this codebase. We also especially thank Raushan Turganbay for her generous discussions and feedbacks on this project.

The codebase borrows from, is inspired by, or builds upon the following code, repos, and/or libraries: LLaVA, Qwen, transformers, etc.

If you use lmms-finetune in your research/project, we’d be very happy if you could 1) give us a star, 2) share this repo with others, or 3) cite this codebase:

@software{Zhang_lmms-finetune,
author = {Zhang, Jingyang and Lin, Yueqian},
license = {Apache-2.0},
title = {{lmms-finetune}},
url = {https://github.com/zjysteven/lmms-finetune}
}

Cette page en français.

Created in February 1992, Log Alpha is one of those logic or IQ test programs. It displays a series of letters, and it’s up to you to find the missing one.

The program does not generate the series itself. It comes with a game editor.

I’m providing you with the source codes for the two programs in this project, in anticipation of a new online or Delphi version.

This game was developed in Turbo Pascal to run under MS-Dos in text mode.

It’s possible that this program is compilable with Free Pascal but I haven’t tried. Units not supplied can be found in the DeveloppeurPascal/librairies-TurboPascal repository. If any are missing, please let me know so that I can add them.

You’ll find the binaries (8 bits) and dependencies in the “release” folder. This is the September 19, 1993 version. You can only run it on an MS-Dos emulator, Windows 3.x or 95. There’s no point in trying it on Windows beyond these versions.

Check out my other open source projects in Turbo Pascal if you’re interested in software archeology.

Follow my development streams of software, video games, mobile applications and websites on my Twitch channel or as replays on Serial Streameur mostly in French.

This source code is distributed under the AGPL 3.0 or later license.

You are generally free to use the contents of this code repository anywhere, provided that:

• you mention it in your projects
• distribute the modifications made to the files supplied in this project under the AGPL license (leaving the original copyright notices (author, link to this repository, license) which must be supplemented by your own)
• to distribute the source code of your creations under the AGPL license.

If this license doesn’t suit your needs, you can purchase the right to use this project under the Apache License 2.0 or a dedicated commercial license (contact the author to explain your needs).

These source codes are provided as is, without warranty of any kind.

Certain elements included in this repository may be subject to third-party usage rights (images, sounds, etc.). They are not reusable in your projects unless otherwise stated.

If you think this project is useful and want to support it, please make a donation to its author. It will help to maintain the code and binaries.

You can use one of those services :

• GitHub Sponsors
• Liberapay
• Patreon
• Paypal

or if you speack french you can subscribe to Zone Abo on a monthly or yearly basis and get a lot of resources as videos and articles.

A collection of Javascript based tools for Wwise, using WAAPI from your browser. Download, unzip anywhere and open index.html to use. Alternatively available on https://waapitools.org for direct use.

This tool is used to find out in which soundbank(s) a wwise event is included, upon selection of the event in the Wwise Authoring Tool, regardless of whether the event is directly included in a bank or through the inclusion of one of its parent folders or WWU. This is designed to work around the issue of Wwise’s Reference View ignoring indirect references (a soundbank appears in an event’s references only if the event is directly included in the bank).

Usage: select an event in Wwise.

The Batch Attenuations Editor is designed to help with the creation and update of large attenuation sets, by interpolating attenuation curves between a short (eg 1m) and a long (eg 100m) attenuation.

Usage:

• Create an attenuations folder or work unit
• Inside, create 2 attenuations with names ending with their max radius (e.g. 1m, 100m)
• Edit the attenuations curves, making sure each curve has a matching number of points between the short/long attenuation
• Select the parent folder
• In Waapitools, choose how many intermediate attenuations you want to create by setting distance intervals
• For each curve (volume, aux sends…) and each point, choose how the point’s coordinates will be interpolated from the shortest to the longest attenuation (linear, quadratic, etc.)
• Commit the new interpolated attenuations to Wwise

The Sampler Keymapper automatically sets MIDI root key and key range parameters on children of a blend container if their names contain a note name (eg MyPianoSample_C#3 is mapped to MIDI root key 49 and its range is set based on neighbouring samples root notes).

Usage:

• Create a blend container
• Inside, create the sound objects representing your sampler notes
  • Each sound object name must end with a note name (e.g. C#3, G7, Eb2…)
• Select the blend container
• From Waapitools, commit the note’s MIDI roots and key ranges to Wwise

Notes Review provides a comprehensive display of all notes in the Wwise project. It’s brutally stupid and will freeze on huge projects.

The Renamer allows for easy search/replace in names of objects in the Actor-Mixer Hierarchy. In addition to the selected Actor-Mixer hierarchy object, it will apply the same renaming to:

• all its children
• all the events referencing it

Usage:

• Select an object in the actor-mixer hierarchy
• Edit the search and replace strings
• Check the changes and commit them to Wwise

The Creator helps with the batch creation of children to the currently selected object, from an object type, a list of names and a common prefix.

Usage:

• Select an parent object in your Wwise project
• Choose an object type to create
• Fill in the list of the names you want to give your new objects
• Optionnally, choose a common prefix for all your new objects
• Check the pending objects list
• Commit the new objects to Wwise

The Nester can ‘nest’ selected objects in new parents of your chosen type. The new parents will be nalmed after their children.

A typical use case would be to create random containers from a list of freshly imported sounds, each set of similarly named sounds getting their own parent.

Usage:

• Select multiple objects in your Wwise project
• Check the tool groups them as desired, based on their names
• Choose the type of object you want to create as their new parents
• Commit the new parents to Wwise

This library is an alternative to “https://github.com/php-curl-class/php-curl-class“. Easy use with CurlRequest and CurlResponse objects.

Install via Composer

$ composer require php-guard/curl

• php: ^7.1

require __DIR__ . '/vendor/autoload.php';

use \PhpGuard\Curl\Curl;
use \PhpGuard\Curl\CurlError;

$this->curl  =  new  Curl();
	
try {
	// Execute a single request
	$response = $this->curl->get('http://example.com'); // Return a CurlResponse
	echo $response->raw();

	// Execute multiple requests
	$responses = $this->curl->multi() // Create a MultiCurl object
		->get('http://example.com')   // Add a get request
		->post('http://example.com')  // Add a post request
		->execute();                  // Return an array of CurlResponse

	foreach ($responses as $response) {
		echo $response->raw();
	}
} catch (CurlError $e) {
	echo 'Error: ' . $curl->getCode(). ': ' . $curl->getMessage(). "\n";
}

\PhpGuard\Curl\Curl

HTTP methods

get(string $url, $query = null, array $headers = []): CurlResponse
post(string $url, $data = null, $query = null, array $headers = []): CurlResponse
put(string $url, $data = null, $query = null, array $headers = []): CurlResponse
patch(string $url, $data = null, $query = null, array $headers = []): CurlResponse
delete(string $url, $data = null, $query = null, array $headers = []): CurlResponse

Run a single request

execute(CurlRequest  $request): CurlResponse

Prepare multiple requests

multi(array  $options  = []): MultiCurl

Edit request and response processing (advanced usage)

getCurlRequestFactory(): CurlRequestFactory
getRequestModifierPipeline(): RequestModifierPipeline

\PhpGuard\Curl\CurlRequest

You can use Curl to execute requests or you can use the CurlRequestFactory to return CurlRequest instances.

Properties url, method and data have getters and setters.

The method setHeaderContentType(string $contentType) is a shortcut for

$curlRequest->getHeaders['Content-Type'] = $contentType

Other methods

execute(bool $throwExceptionOnHttpError = false): CurlResponse
getCurlOptions(): CurlOptions
getHeaders(): Headers

\PhpGuard\Curl\MultiCurl

get(string $url, $query = null, array $headers = []): self
post(string $url, $data = null, $query = null, array $headers = []): self
put(string $url, $data = null, $query = null, array $headers = []): self
patch(string $url, $data = null, $query = null, array $headers = []): self
delete(string $url, $data = null, $query = null, array $headers = []): self
execute(): CurlResponse[]

\PhpGuard\Curl\CurlResponse

statusCode(): int
isError(): bool // True if status code >= 300
headers(): Headers
raw() // Raw content of the response
json() // Array or false if not a json response

\PhpGuard\Curl\CurlRequestFactory

Set the base url for all requests

 setBaseUrl(?string $baseUrl): self

Set the option curl CURLOPT_SSL_VERIFYPEER

 setSslVerifyPeer(bool $value): self

Create a CurlRequest

 create(string $method, string $url, $data = null, $query = null, array $headers = []): CurlRequest

Edit other default curl options

 getDefaultCurlOptions(): CurlOptions
 getDefaultHeaders(): Headers

\PhpGuard\Curl\Collection\CurlOptions

This class implements \ArrayAccess. It can therefore be used as an array.

\PhpGuard\Curl\Collection\Headers

This class implements \ArrayAccess. It can therefore be used as an array.

In addition, the keys are case insensitive.

\PhpGuard\Curl\RequestModifierPipeline

Add an object to modify CURL requests

pipe(RequestModifierInterface $requestModifier): self

By default, FileRequestModifier and PlainTextRequestModifier are active. If necessary, you can add an instance of ProxyRequestModifier

• ProxyRequestModifier allows you to define curl options to use a proxy

• FileRequestModifier is used to manage file paths starting with @ and passed as a parameter by transforming them into CurlFile and then modifying the HTTP Content-Type header.

• PlainTextRequestModifier changes the HTTP Content-Type header to text/plain when a string is passed as a parameter.

The incredible app designed to elevate your Liquid Galaxy experience like never before! With a seamless connection to your Liquid Galaxy rig, you can now control it remotely using facial expressions, voice commands, hand gestures, poses, and even object manipulation all at your fingertips!

The app utilizes the power of the Mediapipe API for recognizing and processing facial gestures, hand gestures, and body poses, making it easy for users to control their Liquid Galaxy experience through their Android device.

• Screenshots
  • Light Theme
  • Dark Theme
  • Map Styles
• Installation
• Contribution

1. Clone this repository to your local machine using the following command:

git clone https://github.com/SidharthMudgil/lg-motion.git

2. Open the project in Android Studio.

3. Build the project and install it on your Android device.

1. Download the latest APK file from the “Releases” section of this GitHub repository.

   Download APK	Download AAB

2. Enable “Unknown Sources” in your Android device settings to allow the installation of apps from external sources.

3. Locate the downloaded APK file and install it on your Android device.

We welcome contributions to LG Motion from the open-source community. If you want to contribute to the project, follow these steps:

1. Fork this repository to your GitHub account.

2. Clone the forked repository to your local machine.

git clone https://github.com/your-username/lg-motion.git

3. Create a new branch with a specific naming scheme that describes the purpose of your contribution. For example:

   • For adding a new feature: feature-add-new-feature
   • For fixing a specific issue: fix-issue-description
   • For general improvements: enhancement-improvement-description

4. Make the necessary changes and improvements in your branch.

5. Test your changes to ensure they are working as expected.

6. Follow the coding style and naming conventions of the existing codebase.

7. Commit your changes and push them to your forked repository:

git commit -m "Add a concise commit message describing your changes"
git push origin your-branch-name

8. Create a pull request from your branch to the main LG Motion repository.

9. Pull request will be reviewed, and if everything is satisfactory, it will be merged into the main repository.

Please provide clear and descriptive pull request messages, along with before and after screenshots, to help with the review process.

Let’s build LG Motion together and make Liquid Galaxy control even more exciting and accessible for everyone!

Quickstart

git clone git@github.com:tgm-hit/latex-protocol.git protocol
cd protocol
./maketex

Contents

• Dependencies
• Usage
  • LaTeX
  • TexStudio
  • ShareLatex
• Options
• Variables

For local compilation a TeX distribution is required. Both TeX Live and MiKTeX are fully supported. The compilation script requires Python 3.

Some features might depend on packages which are not installed by default!
A growing list of optional dependencies can be found here.

Arch Linux

sudo pacman -S python-pygments texlive-meta texlive-langgerman texlive-langenglish texlive-langother texlive-fontsextra

With Python 3 and LaTeX installed you can easily compile your project using the maketex script which simplifies the compilation progress, handles multiple source files and removes unnecessary files.
For most use-cases you only have to run ./maketex which compiles the main.tex file using pdflatex while looking for bibliography and glossary entries.

If (for some reason) you do not want to depend on the maketex script you can also use pdflatex, makeglossaries and bibtex from the shell.

pdflatex -shell-escape main	# Initial compilation
makeglossaries main 		# Compile glossaries
pdflatex -shell-escape main	# Progressive compilation for glossaries
bibtex main 			# Compile bibliography
pdflatex -shell-escape main	# Progressive compilation for bibtex
pdflatex -shell-escape main	# Progressive compilation for bibtex

In TexStudio a custom command can be added under Options → Configure TexStudio → Build → User Commands. The following line completely compiles a LaTeX file with glossaries, bibliography and minted.

pdflatex -shell-escape -interaction=nonstopmode % | txs:///makeglossaries | pdflatex -shell-escape -interaction=nonstopmode % | txs:///bibtex | pdflatex -shell-escape -interaction=nonstopmode % | pdflatex -shell-escape -interaction=nonstopmode % | txs:///view-pdf-internal --embedded

Of course you can also add the maketex script as a user command but you might want to set -lm so TexStudio can find your log files and minted cache after cleanup.

python maketex -lm | txs:///view-pdf-internal --embedded

Overleaf is a popular online latex editor and is also fully supported by this template. Just download the archived repository or latest release and upload as a new project.

Options are added to the \documentclass command usually found in main.tex.

\documentclass[<option1>,<option2>,...]{protocol}

Variables are set as commands with their parameter being the variable value.

\myvariable{value}

QuickCart is a full-fledged e-commerce web application built using Django and Tailwind CSS. It provides a user-friendly shopping experience with features like product management, cart functionality, order tracking, authentication, and more. The application is structured with rendered templates instead of an API-based implementation, ensuring a seamless user experience.

• User registration and login
• Profile management with avatar upload
• Password reset and change password functionality
• Two-factor authentication (2FA) enablement

• Browse and search for products
• View product details
• Add, edit, and delete products (admin only)
• Product reviews and ratings
• Wishlist functionality

• Add and remove items from cart
• Update cart item quantities
• View cart details with total price
• Checkout process with order summary
• Address management for shipping and billing

• Place orders and track order status
• View order history
• Cancel orders if eligible
• Order confirmation page
• Payment processing simulation

• Dark mode support
• Responsive UI built with Tailwind CSS
• Optimized database queries for performance
• Admin dashboard for order and product management

Ensure you have the following installed:

• Python 3.8+
• Django 4+
• SQLite (default) or any supported database
• Tailwind CSS (configured with Django reload)

1. Clone the repository:

   git clone https://github.com/JunaidSumsaal/quickcart.git
   cd quickcart

2. Create a virtual environment and activate it:

   python -m venv venv
   source venv/bin/activate  # On Windows use: venv\Scripts\activate

3. Install dependencies:

   pip install -r requirements.txt

4. Apply database migrations:

   python manage.py migrate

5. Create a superuser:

   python manage.py createsuperuser

6. Run the development server:

   python manage.py runserver

7. Open the application in your browser:

   http://127.0.0.1:8000/
   

quickcart/
├── accounts/         # User authentication and profile management
├── cart/             # Shopping cart functionality
├── orders/           # Order management and tracking
├── products/         # Product catalog and reviews
├── templates/        # HTML templates organized by app
├── static/           # Static files including Tailwind CSS
├── core/             # Settings and configuration
├── manage.py         # Django management script
└── README.md         # Project documentation

This project is configured for deployment on Render. To deploy:

• Ensure environment variables are set for database and secret key.
• Use a production-ready WSGI server like Gunicorn.
• Set up Nginx as a reverse proxy.

Contributions are welcome! Follow these steps:

1. Fork the repository.
2. Create a new branch: git checkout -b feature-branch
3. Commit your changes: git commit -m "Add new feature"
4. Push to the branch: git push origin feature-branch
5. Submit a pull request.

This project is licensed under the MIT License.