This application uses state-of-the-art OSINT and webscraping techniques to find emails and usernames of people who have starred a GitHub repository without the need of authentication. This prjects is useful for developers looking to promote their projects or contact developers with similar interests.
This project is OpenSource, feel free to use, study and/or send pull request.
Key Features
Fast: stargazerz uses multithreading to scrape GitHub pages and find emails and usernames of stargazers.
Easy: stargazerz is easy to use, just define the target repository and the number of threads and you are ready to go.
Powerful: stargazerz uses state-of-the-art OSINT and webscraping techniques to find emails and usernames of stargazers.
Customizable: stargazerz allows you to save the results to a file and choose which results to save.
Free: stargazerz is free and open-source.
Installation
You can install stargazerz using pip:
pip install stargazerz
Usage
importstargazerz# Define Crawlercrawler=stargazerz.Crawler(threads=16, target="Frikallo/stargazerz")
# Run Crawlercrawler.run()
# Get Results after Crawler is donecrawler.print_results()
# Save results to filecrawler.save_results("emails", "emails.txt")
crawler.save_results("stargazers", "stargazers.txt")
crawler.save_results("all", "all.txt")
Example Output
$ python3 stargazerz-example.py
[+] Target: Frikallo/stargazerz
[+] Threads: 16
[+] Starting crawler
[+] Crawler started
[+] Fetching page 1 of stargazers for Frikallo/stargazerz
[+] Fetching page 2 of stargazers for Frikallo/stargazerz
[+] Found 34 stargazers
[+] Fetching emails
Complete ✅: 100%|███████████████| 34/34 [00:18<00:00, 1.40stargazers/s]
[+] Crawler finished
[+] Time: 19.92 seconds
[-] Results
[+] Stargazers: 34
[+] Emails: 26
[+] Emails saved to emails.txt
[+] Stargazers saved to stargazers.txt
[+] All results saved to all.txt
The aim of the project is to create an application to play Tic Tac Toe with a different types of games:
• Player versus Player
• Player versus Random
(the program steps is determined by the method of randomizing of empty spaces on the game field)
• Player versus the MiniMax Algorithm
(the program steps is determined by artificial intelligence by the method of minimizing the maximum possible losses,
which does not give the player a chance to win)
All results of games with the algorithm are saved to the database and are
displayed on the main page of the application and after the game with the
MiniMax Algorithm is finished.
Download all files or clone repository, by default used in memory H2 database, to use SQL database uncomment and set up in property.yml your database and run application locally or at the server
An open source web-app to help you implement the Pomodoro Technique in your daily work routine.
With an easy-to-use interface, you can set your work and break intervals and get started with your Pomodoro sessions in no time.
It also comes with a timer that will alert you when it’s time to take a break or start a new Pomodoro session, so you can stay on track and achieve your goals.
The content of this repository is automatically updated each time a new commit land to the dev branch of ArkScript (see this workflow to learn how it works).
When a commit land to dev on ArkScript, the benchmarks workflow starts
It downloads all the languages versions required and compile ArkScript in release
The run.sh script starts, making use of hyperfine and json reports
The generated json report is then passed to insert_data.py, in charge of creating new entries under data/<language>.json
Data/language.json format
Entries are crafted from the test name (eg ackermann) and the sha256 hash of the source file (in this example, the hash for ackermann/arkscript.ark) ; this way if the source file changes, so does the test since it no longer represents the same thing.
Each test entry is a collection of runs, the newest being the last element of the array, the oldest being the first one. All the times are reported in seconds.
For data/arkscript.json, the commit tested (of ArkScript, not of this repo) is also added.
All pages are meant to load very quickly with few or no external resources. All pages are generated from reStructuredText (reST).
HTML files are never committed to this (“source”) branch. GitHub Actions automatically updates
the published (“master”) branch. Therefore pull requests should be submitted only to the “source” branch.
To locally preview changes and update the HTML after editing an .rst file, run make. To clean all rendered HTML and remake, run make clean all.
This requires a relatively recent Docutils release, since it uses rst2html5. To install rst2html5, run: python3 -m pip install rst2html5.
Release docs
Release documentation is published on RTD and released as part of the official tarballs,
as well as distributed in most distribution packages. These are only valid for their respective releases.
Previously, the documentation was hosted directly here before the move to RTD.
There are still redirects (borgbackup/, borgweb/) to the RTD site here
to keep old URLs working for a while; however, that does not work with subpages.
A minimalist implementation of the Game of Life cellular automaton. Read the details!
Code:
defnext_GameOfLife(universe):
"""Performs a single iteration of Game of Life in a boundless universe."""candidates=defaultdict(int)
for (x,y) inuniverse:
for (dx,dy) in (0,1),(1,0),(0,-1),(-1,0),(1,1),(1,-1),(-1,1),(-1,-1):
candidates[x+dx,y+dy] +=1new_universe=set()
forcell,neighborsincandidates.items():
ifneighbors==3or (neighbors==2andcellinuniverse):
new_universe.add(cell)
returnnew_universedefread_GameOfLife(pattern, origin=(0,0), alive='O'):
"""Reads a pattern and return its set of live cells."""universe=set()
fory,rowinenumerate(pattern):
forx,cellinenumerate(row):
ifcell==alive: universe.add((origin[0]+x, origin[1]+y))
returnuniversedefshow_GameOfLife(universe, X, Y):
"""Prints a rectangular window of the universe on the screen."""print('╔'+'═'* (2*len(X) +1) +'╗')
foryinY: print('║ '+' '.join(' ■'[(x,y) inuniverse] forxinX)+' ║')
print('╚'+'═'* (2*len(X) +1) +'╝')
Example:
# Settings:x_range=range(-3,10)
y_range=range(-6,12)
pattern= ("..OOO..", ##########################"..O.O..", # #"..O.O..", # RIP John Conway #"...O...", # (1937-2020) #"O.OOO..", # #".O.O.O.", # https://xkcd.com/2293/ #"...O..O", # #"..O.O..", ##########################"..O.O..")
# Main loop:universe=read_GameOfLife(pattern)
whileTrue:
show_GameOfLife(universe, x_range, y_range)
universe=next_GameOfLife(universe)
wait=input("\nPress <Return> to perform a step.")
print("\x1b[1A\x1b[2K\x1b[1A\x1b[2K\x1b[1A")
progressr: An Inclusive, Unifying API for Progress Updates
The progressr package provides a minimal API for reporting
progress updates in R. The design is to
separate the representation of progress updates from how they are
presented. What type of progress to signal is controlled by the
developer. How these progress updates are rendered is controlled by
the end user. For instance, some users may prefer visual feedback
such as a horizontal progress bar in the terminal, whereas others may
prefer auditory feedback.
Design motto:
The developer is responsible for providing progress updates but it’s
only the end user who decides if, when, and how progress should be
presented. No exceptions will be allowed.
Two Minimal APIs – One For Developers and One For End-Users
Developer’s API
1. Set up a progressor with a certain number of steps:
p <- progressor(nsteps)
p <- progressor(along = x)
2. Signal progress:
p() # one-step progress
p(amount = 0) # "still alive"
p("loading ...") # pass on a message
End-user’s API
1a. Subscribe to progress updates from everywhere:
handlers(global = TRUE)
y <- slow_sum(1:5)
y <- slow_sum(6:10)
1b. Subscribe to a specific expression:
with_progress({
y <- slow_sum(1:5)
y <- slow_sum(6:10)
})
Assume that we have a function slow_sum() for adding up the values
in a vector. It is so slow, that we like to provide progress updates
to whoever might be interested in it. With the progressr package,
this can be done as:
Note how there are no arguments in the code that specifies how
progress is presented. The only task for the developer is to decide
on where in the code it makes sense to signal that progress has been
made. As we will see next, it is up to the end user of this code to
decide whether they want to receive progress updates or not, and, if
so, in what format.
Without reporting on progress
When calling this function as in:
>y<- slow_sum(1:10)
>y
[1] 55>
it will behave as any function and there will be no progress
updates displayed.
Reporting on progress
If we are only interested in progress for a particular call, we can
do:
However, if we want to report on progress from every call, wrapping
the calls in with_progress() might become too cumbersome. If so, we
can enable the global progress handler:
> library(progressr)
> handlers(global=TRUE)
so that progress updates are reported on wherever signaled, e.g.
This requires R 4.0.0 or newer. To disable this again, do:
> handlers(global=FALSE)
In the below examples, we will assume handlers(global = TRUE) is
already set.
Customizing how progress is reported
Terminal-based progress bars
The default is to present progress via utils::txtProgressBar(),
which is available on all R installations. It presents itself as an
ASCII-based horizontal progress bar in the R terminal. This is
rendered as:
We can tweak this “txtprogressbar” handler to use red hearts for the
bar, e.g.
To change the default, to, say, cli_progress_bar() by the cli
package, set:
handlers("cli")
This progress handler will present itself as:
To instead use progress_bar() by the progress package, set:
handlers("progress")
This progress handler will present itself as:
To set the default progress handler, or handlers, in all your R
sessions, call progressr::handlers(...) in your
~/.Rprofile startup file.
Auditory progress updates
Progress updates do not have to be presented visually. They can
equally well be communicated via audio. For example, using:
handlers("beepr")
will present itself as sounds played at the beginning, while progressing, and at the end (using different beepr sounds). There will be no output written to the terminal;
>y<- slow_sum(1:10)
>y
[1] 55>
Concurrent auditory and visual progress updates
It is possible to have multiple progress handlers presenting progress
updates at the same time. For example, to get both visual and
auditory updates, use:
handlers("txtprogressbar", "beepr")
Silence all progress
To silence all progress updates, use:
handlers("void")
Further configuration of progress handlers
Above we have seen examples where the handlers() takes one or more
strings as input, e.g. handlers(c("progress", "beepr")). This is
short for a more flexible specification where we can pass a list of
handler functions, e.g.
With this construct, we can make adjustments to the default behavior
of these progress handlers. For example, we can configure the
format, width, and complete arguments of
progress::progress_bar$new(), and tell beepr to use a different
finish sound and generate sounds at most every two seconds by
setting:
As seen above, some progress handlers present the progress message as
part of its output, e.g. the “progress” handler will display the
message as part of the progress bar. It is also possible to “push”
the message up together with other terminal output. This can be done
by adding class attribute "sticky" to the progression signaled.
This works for several progress handlers that output to the terminal.
For example, with:
Use regular output as usual alongside progress updates
In contrast to other progress-bar frameworks, output from message(),
cat(), print() and so on, will not interfere with progress
reported via progressr. For example, say we have:
slow_sqrt<-function(xs) {
p<- progressor(along=xs)
lapply(xs, function(x) {
message("Calculating the square root of ", x)
Sys.sleep(2)
p(sprintf("x=%g", x))
sqrt(x)
})
}
This works because progressr will briefly buffer any output
internally and only release it when the next progress update is
received just before the progress is re-rendered in the terminal.
This is why you see a two second delay when running the above example.
Note that, if we use progress handlers that do not output to the
terminal, such as handlers("beepr"), then output does not have to be
buffered and will appear immediately.
Comment: When signaling a warning using warning(msg, immediate. = TRUE) the message is immediately outputted to the standard-error
stream. However, this is not possible to emulate when warnings are
intercepted using calling handlers, which are used by
with_progress(). This is a limitation of R that cannot be worked
around. Because of this, the above call will behave the same as
warning(msg) – that is, all warnings will be buffered by R
internally and released only when all computations are done.
Support for progressr elsewhere
Note that progression updates by progressr is designed to work out
of the box for any iterator framework in R. Below is an set of
examples for the most common ones.
Note how this solution does not make use of plyr‘s .progress
argument, because the above solution is more powerful and more
flexible, e.g. we have more control on progress updates and their
messages. However, if you prefer the traditional plyr approach,
you can use .progress = "progressr", e.g. y <- llply(..., .progress = "progressr").
The knitr package
When compiling (“knitting”) an knitr-based vignette, for instance, via
knitr::knit(), knitr shows the progress of code chunks
processed thus far using a progress bar. In knitr (>= 1.42) [to
be released as of 2022-12-12], we can use progressr for this
progress reporting. To do this, set R option knitr.progress.fun as:
to report on progress via the cli package as map() is iterating
over the elements. Now, instead of using the default, built-in
cli progress bar, we can customize cli to report on progress
via progressr instead. To do this, set R option
cli.progress_handlers as:
options(cli.progress_handlers="progressr")
With this option set, cli will now report on progress according to
your progressr::handlers() settings. For example, with:
progressr::handlers(c("beepr", "rstudio"))
will report on progress using beepr and the RStudio Console
progress panel.
To make cli report via progressr in all your R session, set
the above R option in your ~/.Rprofile startup file.
Note: A cli progress bar can have a “name”, which can be
specfied in purrr function via argument .progress,
e.g. .progress = "processing". This name is then displayed in front
of the progress bar. However, because the progressr framework
does not have a concept of progress “name”, they are silently ignored
when using options(cli.progress_handlers = "progressr").
Parallel processing and progress updates
The future framework, which provides a unified API for parallel
and distributed processing in R, has built-in support for the kind of
progression updates produced by the progressr package. This means
that you can use it with for instance future.apply, furrr,
and foreach with doFuture, and plyr or
BiocParallel with doFuture. In contrast, non-future
parallelization methods such as parallel‘s mclapply() and,
parallel::parLapply(), and foreach adapters like doParallel
do not support progress reports via progressr.
future_lapply() – parallel lapply()
Here is an example that uses future_lapply() of the future.apply package to parallelize on the local machine while at the same time signaling progression updates:
Here is an example that uses foreach() of the foreach package
together with %dofuture% of the doFuture package to
parallelize while reporting on progress. This example parallelizes on
the local machine, it works also for remote machines:
For existing code using the traditional %dopar% operators of the
foreach package, we can register the doFuture adapter and
use the same progressr as above to progress updates;
Here is an example that uses future_map() of the furrr package
to parallelize on the local machine while at the same time signaling
progression updates:
Note: This solution does not involved the .progress = TRUE
argument that furrr implements. Because progressr is more
generic and because .progress = TRUE only supports certain future
backends and produces errors on non-supported backends, I recommended
to stop using .progress = TRUE and use the progressr package
instead.
BiocParallel::bplapply() – parallel lapply()
Here is an example that uses bplapply() of the BiocParallel
package to parallelize on the local machine while at the same time
signaling progression updates:
Note: As an alternative to the above, recommended approach, one can
use .progress = "progressr" together with .parallel = TRUE. This
requires plyr (>= 1.8.7).
Near-live versus buffered progress updates with futures
As of August 2025, there are six types of future backends that are
known(*) to provide near-live progress updates:
sequential,
multicore,
multisession, and
cluster (local and remote)
future.callr::callr
future.mirai::mirai_multisession
Here “near-live” means that the progress handlers will report on
progress almost immediately when the progress is signaled on the
worker. For all other future backends, the progress updates are only
relayed back to the main machine and reported together with the
results of the futures. For instance, if future_lapply(X, FUN)
chunks up the processing of, say, 100 elements in X into eight
futures, we will see progress from each of the 100 elements as they
are done when using a future backend supporting “near-live” updates,
whereas we will only see those updated to be flushed eight times when
using any other types of future backends.
(*) Other future backends may gain support for “near-live” progress
updating later. Adding support for those is independent of the
progressr package. Feature requests for adding that support
should go to those future-backend packages.
Note of caution – sending progress updates too frequently
Signaling progress updates comes with some overhead. In situation
where we use progress updates, this overhead is typically much smaller
than the task we are processing in each step. However, if the task we
iterate over is quick, then the extra time induced by the progress
updates might end up dominating the overall processing time. If that
is the case, a simple solution is to only signal progress updates
every n:th step. Here is a version of slow_sum() that signals
progress every 10:th iteration:
slow_sum <- function(x) {
p <- progressr::progressor(length(x) / 10)
sum <- 0
for (kk in seq_along(x)) {
Sys.sleep(0.1)
sum <- sum + x[kk]
if (kk %% 10 == 0) p(message = sprintf("Adding %g", x[kk]))
}
sum
}
The overhead of progress signaling may depend on context. For
example, in parallel processing with near-live progress updates via
‘multisession’ futures, each progress update is communicated via a
socket connections back to the main R session. These connections
might become clogged up if progress updates are too frequent.
Progress updates in non-interactive mode (“batch mode”)
When running R from the command line, R runs in a non-interactive mode
(interactive() returns FALSE). The default behavior of
progressr is to not report on progress in non-interactive mode.
To reported on progress also then, set R options progressr.enable or
environment variable R_PROGRESSR_ENABLE to TRUE. For example,
Because this project is under active development, the progressr API is
currently kept at a very minimum. This will allow for the framework
and the API to evolve while minimizing the risk for breaking code that
depends on it. The roadmap for developing the API is roughly:
Provide minimal API for producing progress updates,
i.e. progressor(), with_progress(), handlers()
Add support for global progress handlers removing the need for
the user having to specify with_progress(),
i.e. handlers(global = TRUE) and handlers(global = FALSE)
Make it possible to create a progressor also in the global
environment (see ‘Known issues’ below)
Add support for nested progress updates
Add API to allow users and package developers to design
additional progression handlers
A progressor cannot be created in the global environment
It is not possible to create a progressor in the global environment,
e.g. in the the top-level of a script. It has to be created inside a
function, within with_progress({ ... }), local({ ... }), or a
similar construct. For example, the following:
Error in progressor(along = xs) :
A progressor must not be created in the global environment unless wrapped in a
with_progress() or without_progress() call. Alternatively, create it inside a
function or in a local() environment to make sure there is a finite life span
of the progressor
The solution is to wrap it in a local({ ... }) call, or more
explicitly, in a with_progress({ ... }) call:
The main reason for this is to limit the life span of each progressor.
If we created it in the global environment, there is a significant
risk it would never finish and block all of the following progressors.
The global progress handler cannot be set everywhere
It is not possible to call handlers(global = TRUE) in all
circumstances. For example, it cannot be called within tryCatch()
and withCallingHandlers();
This is not a bug – neither in progressr nor in R itself. It’s due
to a conservative design on how global calling handlers should work
in R. If it allowed, there’s a risk we might end up getting weird and
unpredictable behaviors when messages, warnings, errors, and other
types of conditions are signaled.
Because tryCatch() and withCallingHandlers() is used in many
places throughout base R, this means that we also cannot call
handlers(global = TRUE) as part of a package’s startup process,
e.g. .onLoad() or .onAttach().
Another example of this error is if handlers(global = TRUE) is used
inside package vignettes and dynamic documents such as Rmarkdown. In
such cases, the global progress handler has to be enabled prior to
processing the document, e.g.
When using the progressr package, progression updates are
communicated via R’s condition framework, which provides methods for
creating, signaling, capturing, muffling, and relaying conditions.
Progression updates are of classes progression and
immediateCondition(*). The below figure gives an example how
progression conditions are created, signaled, and rendered.
(*) The immediateCondition class of conditions are relayed as soon
as possible by the future framework, which means that
progression updates produced in parallel workers are reported to the
end user as soon as the main R session have received them.
Figure: Sequence diagram illustrating how signaled progression
conditions are captured by with_progress(), or the global
progression handler, and relayed to the two progression handlers
‘progress’ (a progress bar in the terminal) and ‘beepr’ (auditory)
that the end user has chosen.
copy your git token on set token “” (line 13, COPY TO CLIPBOARD section) into “”
vim ~/.dotfiles/config/sxhkd/SxhkdUtils
pair bluetooth headphones with this guide – https://wiki.archlinux.org/title/bluetooth#Pairing
copy the id into clipboard (can look like: 04:CB:88:C8:1D:A4)
and paste it next to connect (leave one space between connect and id) (line 103, BLUETOOTH HEADPHONES section)
vim ~/.dotfiles/config/sxhkd/SxhkdUtils
create basic home dirs (if they dont exist already)
BedrockIfy is a fabric Minecraft Mod that implements some useful Minecraft Bedrock Edition features into Minecraft Java Edition.
Features
Bedrock-like loading screens with helpful tips.
Third person eating animations.
Position and “paper doll” overlay.
Dynamic Inactive Hud Opacity.
Saving status overlay.
3D fishing hook
Bedrock Cauldrons that hold dyed water and potions
Bedrock Sun Glare
Bedrock Crafting Recipes (Toggleable).
Bedrock-like chat.
Bedrock Edition world color noise for grass and water.
Idle hand animations.
Held item descriptions (enchantments, books and potions).
Reach-around block placement.
Quick armor swap.
Dying Trees!
Bedrock Light block shading.
Disable flying momentum (Drift) in creative mode.
Stop elytra flying by pressing space on air.
Bedrock bonemeal functionality for flowers and sugar cane.
Bigger baby villager heads.
Bedrockify also includes “eye-candy” features like the ability use the rotating title screen background in all option screens instead of the boring vanilla dirt background.
All Features are customizable through the In-Game BedrockIfy Settings Menu!
https://github.com/Frikallo/stargazerz
