FreeBSD New Ports Index

This page is a slightly modified version of the following one-liner output. created_at: 2023-08-10T12:50:50+09:00

# git -C /usr/ports log --diff-filter=A --name-status --pretty="format:%aI %H" origin/master | perl -nlE '/^\d/ ? $d=$_ : print "$d\t$_"' | ack "\t[0-9a-z-]+/[^/ ]+/Makefile$"
timestamp origin comment / pkg-descr
2023-08-09T20:43:31+02:00 security/git-credential-azure Git credential helper for Azure Repos
git-credential-azure is a Git credential helper that authenticates to
Azure Repos (dev.azure.com). Azure Repos is part of Azure DevOps.

The first time you authenticate, the helper opens a browser window to
Microsoft login. Subsequent authentication is non interactive.
2023-08-09T20:25:15+02:00 x11-toolkits/wlinfo Window information utility for Wayland
Wlinfo queries Wayland for information about physical displays connected
to the system. It can print information about the physical dimensions of
such displays, and screen resolution, and display scaling
characteristics.
2023-08-08T04:32:44-04:00 security/su-exec Switch user and group id and exec
su-exec is a simple tool that will simply execute a program with
different privileges. The program will be executed directly and not
run as a child, like su and sudo does, which avoids TTY and signal
issues.
2023-08-08T03:35:55-04:00 graphics/vhs Your CLI home video recorder
VHS is a CLI home video recorder that provides an intuitive way to
write custom terminal GIFs as code for integration testing and
demoing your CLI tools.
2023-08-07T20:44:13+02:00 www/angie-module-xslt Angie XSLT dynamic module
Module is a filter that transforms XML responses using XSLT stylesheets.
Module allows you to apply an XSLT transformation on an XML file or
response received from a backend server before serving the client.
2023-08-07T20:43:07+02:00 www/angie-module-redis2 Angie redis2 dynamic module
Module makes Angie talk to a Redis 2.x server in a non-blocking way. The full
Redis 2.0 unified protocol has been implemented including the Redis pipelining
support. This module returns the raw TCP response from the Redis server.
2023-08-07T20:41:50+02:00 www/angie-module-perl Angie Perl dynamic module
Module is used to implement location and variable handlers in Perl and insert
Perl calls into SSI.
2023-08-07T20:37:18+02:00 www/angie-module-njs Angie NJS dynamic module
Module is a subset of the JavaScript language that allows extending
Angie functionality. Package contains http_js and stream_js modules to
provide objects, methods and properties for extending related functionality.
2023-08-07T20:34:43+02:00 www/angie-module-keyval Angie keyval dynamic module
Module creates variables with values taken from key-value pairs.
Key-value database is stored in shared memory or Redis as specified by the
configuration parameter.
2023-08-07T20:32:57+02:00 www/angie-module-jwt Angie JWT dynamic module
Module provides JWT validity check functionality for Angie.
Module intends to be as light as possible and to remain simple.
Supports number of key encodings and allows to keep it in a designated file.
2023-08-07T20:30:02+02:00 www/angie-module-image-filter Angie image-filter dynamic module
Module is a filter that transforms images in JPEG, GIF, PNG, and WebP formats.
Transformation capabilities include crop, resize, rotate, and others. Several
resulting image options are configurable.
2023-08-07T20:28:09+02:00 www/angie-module-cache-purge Angie cache_purge dynamic module
Module adds ability to purge content from FastCGI, proxy, SCGI and uWSGI
caches. A purge operation removes the content with the same cache key as the
purge request has. This module is production-ready.
2023-08-07T20:24:32+02:00 www/angie-module-brotli Angie Brotli dynamic module
Module adds Brotli compression support to Angie.
Brotli is a generic-purpose lossless compression algorithm that compresses
data using a combination of a modern variant of the LZ77 algorithm, Huffman
coding and 2nd order context modeling, with a compression ratio comparable
to the best currently available general-purpose compression methods.
2023-08-07T20:21:57+02:00 www/angie-module-auth-jwt Angie auth-jwt dynamic module
Module implements client authorization by validating the provided
JSON Web Token (JWT) using the specified keys. The module supports
JSON Web Signature (JWS) and can be used for OpenID Connect authentication.
2023-08-09T11:30:18+00:00 mail/mfmod_openmetrics OpenMetrics support loadable module for mailfromd
This package is a loadable module for mailfromd which adds OpenMetrics
support to the mail filtering language (MFL).
2023-08-09T11:21:50+00:00 mail/mfmod_pcre PCRE support loadable module for mailfromd
This package is a loadable module for mailfromd which adds Perl-
compatible regular expressions to the mail filtering language (MFL).
2023-08-09T10:35:26+01:00 security/R-cran-sodium R bindings to libsodium
Bindings to libsodium: a modern, easy-to-use software library for
encryption, decryption, signatures, password hashing and more. Sodium
uses curve25519, a state-of-the-art Diffie-Hellman function by Daniel
Bernstein, which has become very popular after it was discovered that
the NSA had backdoored Dual EC DRBG.

2023-08-06T12:10:06+02:00 sysutils/swtpm Libtpms-based TPM emulator
The SWTPM package provides TPM emulators with different front-end interfaces
to libtpms. TPM emulators provide socket interfaces (TCP/IP and Unix) and
the Linux CUSE interface for the creation of multiple native /dev/vtpm* devices.
2023-08-06T10:53:53+02:00 sysutils/libtpms This library provides emulation of a Trusted Platform Module
Libtpms is a library that targets the integration of TPM functionality into
hypervisors, primarily into Qemu. Libtpms provides a very narrow public API for
this purpose so that integration is possible. Only the minimum of necessary
APIs are made publicly available.
2023-08-09T07:02:46+00:00 mail/mfmod_ldap LDAP support loadable module for mailfromd
This package is a loadable module for mailfromd that adds support for
searching in LDAP directories to the mail filtering language (MFL).
2023-08-08T14:02:38+03:00 security/botan3 Portable, easy to use and efficient C++ crypto library
Botan is a crypto library written in C++. It provides a variety of
cryptographic algorithms, including common ones such as AES, MD5, SHA,
HMAC, RSA, Diffie-Hellman, DSA, and ECDSA, as well as many others that
are more obscure or specialized. It also offers X.509v3 certificates
and CRLs, and PKCS #10 certificate requests. A message processing
system that uses a filter/pipeline metaphor allows for many common
cryptographic tasks to be completed with just a few lines of code.
Assembly optimizations for common CPUs, including x86, x86-64, and
PowerPC, offers further speedups for critical tasks such as SHA-1
hashing and multiple precision integer operations.

Botan is licensed under the same permissive terms as FreeBSD itself.
2023-06-04T15:16:42+03:00 ports-mgmt/pkg-appstream Pkg plugin for downloading AppStream metadata
This libpkg plugin is supposed to fill /var/lib/swcatalog/xml/ directory with
up-to-date AppStream metadata from pkg repositories that support that.
2023-08-07T18:50:57-07:00 devel/json-fortran Modern Fortran JSON API
JSON-Fortran is a user-friendly, thread-safe, and object-oriented API for
reading and writing JSON files, written in modern Fortran.
2023-08-06T10:34:43-05:00 devel/py-cykhash Cython equivalent to khash-sets/maps
Cykhash is a cython equivalent to khash-sets/maps, efficient
implementation of isin and unique

Benefits:

Brings functionality of khash to Python and Cython and can be used
seamlessly in numpy or pandas.

Numpy's world is lacking the concept of a (hash-)set. This
shortcoming is fixed and efficient (memory- and speedwise compared
to pandas') unique and isin are implemented.

Python-set/dict have big memory-footprint. For some datatypes the
overhead can be reduced by using khash by factor 4-8.
2023-07-18T16:19:22+02:00 devel/bloomberg-bde foundational C++ libraries used at Bloomberg
BDE stands for BDE Development Environment. Depending on the context,
BDE may refer to a suite of low-level C++ libraries, the methodology that
guides their development, or to the team that develops them. The BDE
libraries meet superior standards of design, documentation, and testing
and are the foundation of C++ development at Bloomberg. Among other things,
the BDE libraries provide an enhanced implementation of STL containers,
vocabulary types for representing common concepts (like dates and times),
and building blocks for developing multi-threaded applications and
network applications.
2023-08-05T14:26:39+02:00 www/angie-module-geoip2 Angie GeoIP2 dynamic module
Module captures information from the client IP address in variables,
using the MaxMind GeoIP2 databases.
2023-08-05T12:04:07+02:00 devel/g-golf Guile Object Library for GNOME
G-Golf is a gobject-introspection based dynamic binding to
GObject-based libraries, enabling the use of the GNOME platform to
build full-featured graphical apps directly from Guile.
2023-08-05T20:57:25+02:00 multimedia/obuparse Simple and portable single file AV1 OBU parser
Simple and portable single file AV1 OBU parser written in mostly C89 with a
tiny bit of C99.

* No allocations; only works on user-provided buffers and the stack.
* OBU header parsing.
* Sequence Header OBU parsing.
* Metadata OBU parsing.
* Tile List OBU parsing.
* Tile Group OBU parsing.
* Frame Header OBU parsing.
* Frame OBU parsing.

2023-08-05T11:38:40-07:00 science/gcp Geometrical Counter-Poise Correction
Geometrical Counter-Poise Correction
for quantum chemistry.
2023-07-27T20:41:53+01:00 mail/py-dkimpy-milter DKIM signing and verification milter
This is a DKIM signing and verification milter. It has been tested
with both Postfix and Sendmail.
2023-08-04T23:05:10+02:00 net/py-mpi4py-mpich Python bindings for MPI (MPICH)
2023-08-03T00:00:47-07:00 science/py-dftd4 Python API of the DFT-D4 project
py-dftd4 is a python binding for dftd4 (D4).

D4 is a generally applicable atomic-charge dependent london dispersion
correction calculator.
2023-02-21T19:50:52+02:00 x11-fonts/juliamono Monospaced typeface with many Unicode characters
JuliaMono is a monospaced typeface designed for programming in text
editing environments that require a wide range of specialist and
technical Unicode characters.
2023-07-31T15:05:59-04:00 devel/lua-Penlight Comprehensive set of libraries for Lua
Penlight is a set of pure Lua libraries for making it easier to work with
common tasks like iterating over directories, reading configuration files and
the like. Provides functional operations on tables and sequences.
2023-07-31T09:59:54+02:00 devel/jetbrains-sqlite IntelliJ SQLite native library
IntelliJ SQLite native library.
2023-08-01T18:47:16-07:00 textproc/py-json2html JSON to HTML Table Representation
json2html is a Python module for converting complex JSON to HTML Table
representation.
2023-08-01T16:11:19-04:00 devel/libwasmtime Library for fast and secure runtime for WebAssembly
Wasmtime is a Bytecode Alliance project that is a standalone
wasm-only optimizing runtime for WebAssembly and WASI. It runs
WebAssembly code outside of the Web, and can be used both as a
command-line utility or as a library embedded in a larger
application.
2023-08-01T13:01:19-04:00 graphics/libxisf Library to read and write XISF files produced by PixInsight
LibXISF is C++ library that can read and write XISF files produced by
PixInsight. It implements the XISF 1.0 specification.
2023-08-01T02:30:48-07:00 science/py-nglview IPython widget to view molecular structures and trajectories
nglview is an IPython/Jupyter widget to interactively view molecular structures
and trajectories. Utilizes the embeddable NGL Viewer for rendering. Support for
showing data from the file-system, RCSB PDB, simpletraj and from objects of
analysis libraries mdtraj, pytraj, mdanalysis, ParmEd, rdkit, ase, HTMD,
biopython, cctbx, pyrosetta, schrodinger's Structure.
2023-08-01T02:20:09-07:00 devel/py-versioneer-518 Easy VCS-based management of project version strings
Versioneer is a tool for managing a recorded version number in setuptools-based
python projects. The goal is to remove the tedious and error-prone "update the
embedded version string" step from your release process. Making a new release
should be as easy as recording a new tag in your version-control system, and
maybe making new tarballs.
2023-07-31T19:16:29+01:00 devel/llvm17 LLVM and Clang
The LLVM Project is a collection of modular and reusable compiler and
toolchain technologies.

This port includes Clang (a C/C++/Objective-C compiler), LLD (a linker),
LLDB (a debugger), an OpenMP runtime library, and the LLVM infrastructure
these are built on.
2023-08-01T04:08:58+08:00 net/speedtest Internet connection measurement for developers
Speedtest CLI brings the trusted technology and global server network behind
Speedtest to the command line. Built for software developers, system
administrators and computer enthusiasts alike, Speedtest CLI is the first
official Linux-native Speedtest application backed by Ookla.

With Speedtest CLI, you can easily:
- Measure internet connection performance metrics like download, upload, latency
and packet loss natively without relying on a web browser
- Test the internet connection of your Linux desktop, a remote server or even
lower-powered devices such as the Raspberry Pi with the Speedtest Server
Network
- Set up automated scripts to collect connection performance data, including
trends over time
- Use Speedtest in your programs by wrapping it in the programming language of
your choice
- View test results via CSV, JSONL or JSON
2023-08-01T00:27:31+08:00 databases/rubygem-attr_json Serialized json-hash-backed ActiveRecord attributes
ActiveRecord attributes stored serialized in a json column, super smooth.

Typed and cast like Active Record. Supporting nested models, dirty tracking,
some querying (with postgres jsonb contains), and working smoothy with form
builders.

Use your database as a typed object store via ActiveRecord, in the same models
right next to ordinary ActiveRecord column-backed attributes and associations.
Your json-serialized attr_json attributes use as much of the existing
ActiveRecord architecture as we can.
2023-08-01T00:27:30+08:00 www/py-requests-cache0 Persistent cache for python requests
requests-cache is a transparent, persistent cache that provides an easy way to
get better performance with the python requests library.

Features:
- Ease of use: Keep using the requests library you're already familiar with. Add
caching with a drop-in replacement for requests.Session, or install globally
to add caching to all requests functions.
- Performance: Get sub-millisecond response times for cached responses. When
they expire, you still save time with conditional requests.
- Persistence: Works with several storage backends including SQLite, Redis,
MongoDB, and DynamoDB; or save responses as plain JSON files, YAML, and more
- Customization: Works out of the box with zero config, but with a robust set of
features for configuring and extending the library to suit your needs
- Expiration: Keep your cache fresh using Cache-Control, eagerly cache
everything for long-term storage, use URL patterns for selective caching, or
any combination of strategies
- Compatibility: Can be combined with other popular libraries based on requests
2023-08-01T00:27:27+08:00 devel/py-jsonschema417 JSON Schema validation for Python
jsonschema is an implementation of JSON Schema for Python

- Full support for Draft 3 and Draft 4 of the schema.
- Lazy validation that can iteratively report all validation errors.
- Small and extensible
- Programmatic querying of which properties or items failed validation.
2023-08-01T00:27:26+08:00 devel/py-deptry CLI utility to check for unused, missing and transitive dependencies
deptry is a command line tool to check for issues with dependencies in a Python
project, such as unused or missing dependencies. It supports the following types
of projects:
- Projects that use Poetry and a corresponding pyproject.toml file
- Projects that use PDM and a corresponding pyproject.toml file
- Projects that use a requirements.txt file according to the pip standards

Dependency issues are detected by scanning for imported modules within all
Python files in a directory and its subdirectories, and comparing those to the
dependencies listed in the project's requirements.
2023-07-31T10:22:39-05:00 deskutils/freebsd-update-notify Notify desktop user when FreeBSD updates are available
Freebsd-update-notify is a script invoked by cron to check for
available updates and issue popup notification on the desktop. The
user can elect to install and reboot or ignore them for now.
2023-07-31T16:19:34+09:00 x11/damask Automatically set wallpaper images from Internet sources
Damask is an application that will automatically set wallpaper images
by selecting images from a variety of sources, including local files
and folders. It currently supports setting the wallpaper image from
the following sources:

- wallhaven.cc
- Microsoft Bing Wallpaper of the day
- NASA Astronomy Picture of the Day
- Unsplash
2023-07-31T16:16:31+09:00 x11/xdg-desktop-portal-gnome Backend implementation for xdg-desktop-portal for GNOME
xdg-desktop-portal-gnome is a backend implementation for
xdg-desktop-portal that is using GTK and various pieces of GNOME
infrastructure, such as the org.gnome.Shell.Screenshot or
org.gnome.SessionManager D-Bus interfaces.
2023-07-31T16:11:13+09:00 security/bitwarden-cli Bitwarden client command-line interface
The Bitwarden CLI is a powerful, full-featured command-line interface
(CLI) tool to access and manage a Bitwarden vault. The CLI is written
with TypeScript and Node.js and can be run on Windows, macOS, and
Linux distributions.
2023-07-29T07:24:41+02:00 textproc/py-sphinx-sitemap Sphinx extension for generating sitemaps for HTML
A Sphinx extension to generate multi-version, and multi-language HTML sitemaps
for generated documentation. py-sphinx-sitemap is compliant with the
Sitemaps.org XML schema for declaring and generating HTML sitemaps.
2023-07-28T20:24:48+02:00 x11/oscar Open Source CPAP Analysis Reporter
OpenSource CPAP Analysis Reporter

OSCAR is a derivative of SleepyHead version 1.1.0, created when that
was abandoned by Mark Watkins.

SleepyHead was a cross platform, opensource sleep tracking program for
reviewing CPAP and Oximetry data, which are devices used in the
treatment of Sleep Disorders like Obstructive Sleep Apnea.
2023-07-28T14:58:44+02:00 lang/guile3 GNU Ubiquitous Intelligent Language for Extension
GUILE, GNU's Ubiquitous Intelligent Language for Extension,
is a library that implements the Scheme language plus various
convenient facilities. It's designed so that you can link it
into an application or utility to make it extensible. Our
plan is to link this library into all GNU programs that call for
extensibility.
2023-07-28T14:58:44+02:00 lang/guile-aclocal
2023-07-30T21:57:39+00:00 emulators/wine7 Microsoft Windows compatibility environment
Wine is a Microsoft Windows compatibility layer (or program loader)
capable of running Windows applications on i386 and compatible CPUs.
Windows programs running in Wine act as native programs would, running
without the performance or memory usage penalties of an emulator, with
a similar look and feel to other applications on your desktop.

Many applications already work, more or less, including versions of
Microsoft Office and many games.

If you receive a message of "Did you reconfigure your kernel with
"options USER_LDT"?" add the line
machdep.max_ldt_segment="2048"
to /boot/loader.conf and reboot.

Gerald Pfeifer <gerald@FreeBSD.org>
2023-07-29T21:12:31+02:00 sysutils/sispmctl CLI tool to manage USB controlled powerstrips produced by GEMBIRD LTD
sispmctl is an application for managing USB controlled
powerstrips produced by GEMBIRD LTD.
Newer devices are sold under the Energenie brand.

The following devices are supported:
* Gembird MSIS-PM
* Gembird Silver Shield SIS-PM (aka Revolt Intelliplug)
* Gembird Silver Shield SIS-PMS
* Energenie EG-PM
* Energenie EG-PMS
* Energenie EG-PM2
* Energenie EG-PMS2
2023-07-29T08:57:27-04:00 devel/scc LOC counter with COCOMO and complexity estimation
scc is a very fast and accurate code counter. In addition, it estimates
code complexity and performs COCOMO (constructive code model) calculations.
2023-07-28T10:41:58-05:00 biology/py-htseq Python library to facilitate programmatic analysis of sequence data
HTSeq is a Python library to facilitate programmatic analysis of data
from high-throughput sequencing (HTS) experiments. A popular component
of HTSeq is htseq-count, a script to quantify gene expression in bulk
and single-cell RNA-Seq and similar experiments.
2023-07-28T00:44:49-07:00 cad/py-amaranth Amaranth hardware definition language
The Amaranth project provides an open-source toolchain for developing hardware
based on synchronous digital logic using the Python programming language, as
well as evaluation board definitions, a System on Chip toolkit, and more. It
aims to be easy to learn and use, reduce or eliminate common coding mistakes,
and simplify the design of complex hardware with reusable components.

The Amaranth toolchain consists of the Amaranth hardware definition language,
the standard library, the simulator, and the build system, covering all steps of
a typical FPGA development workflow. At the same time, it does not restrict the
designer's choice of tools: existing industry-standard (System)Verilog or VHDL
code can be integrated into an Amaranth-based design flow, or, conversely,
Amaranth code can be integrated into an existing Verilog-based design flow.
2023-07-27T23:03:06-07:00 cad/py-pyvcd Python VCD file support
The PyVCD package writes Value Change Dump (VCD) files as specified
in IEEE 1364-2005.
2023-07-27T17:21:52-04:00 x11-toolkits/py-qt6-datavis3d Python bindings for the Qt6 data visualization library
PyQt6-DataVisualization is a set of Python bindings for The Qt Company's
Qt Data Visualization library. The bindings sit on top of PyQt6 and are
implemented as a single module.
2023-07-27T16:29:03-04:00 graphics/py-qt6-3d Python bindings for the Qt6 3D framework
PyQt6-3D is a set of Python bindings for The Qt Company's Qt 3D
framework. The bindings sit on top of PyQt6 and are implemented as six
separate modules corresponding to the different libraries that make up
the framework.

2023-07-27T07:24:46-04:00 www/qt6-httpserver Lightweight HTTP Server
Qt HTTP Server provides building blocks for embedding a lightweight HTTP
server based on RFC 2616 in an application. There are classes for the messages
sent and received, and for the various parts of an HTTP server.
2023-07-27T07:24:46-04:00 graphics/qt6-quickeffectmaker Tool for creating shader effects for Qt Quick
Qt Quick Effect Maker is a tool for creating shader effects for Qt
Quick with high productivity and performance.
2023-07-27T07:24:46-04:00 devel/qt6-location Qt 6 API to create viable mapping solutions
The Qt Location API helps you create viable mapping solutions using the
data available from some of the popular location services.

The Qt Location API enables you to:
- access and present map data,
- support touch gesture on a specific area of the map,
- query for a specific geographical location and route,
- add additional layers on top, such as polylines and circles,
- and search for places and related images.

2023-07-27T17:04:34+08:00 x11-wm/emwm-utils Enhanced Motif Window Manager Utilities
Goodies for use with EMWM (Enhanced Motif Window Manager): XmToolbox, a
toolchest like application launcher, which reads it's multi-level menu structure
from a simple plain-text file ~/.toolboxrc, and XmSm, a simple session manager
that provides session configuration, locking and shutdown/suspend options.
2023-05-14T17:51:08+00:00 x11/wlr-which-key Keymap manager for wlroots-based compositors
Keymap manager for wlroots-based compositors. Inspired by which-key.nvim.
2023-07-26T01:55:16-07:00 devel/unordered-dense Fast & densely stored hashmap and hashset
unordered-dense implements a fast & densely stored hashmap and hashset based on
robin-hood backward shift deletion for C++17 and later.
2023-07-23T23:16:31+02:00 sysutils/initool Manipulate INI files from the command line
Initool lets you manipulate the contents of INI files from the
command line. It is a rewrite of an earlier program by the same
developer called "iniparse". Rather than modify INI files in place
like iniparse, however, it prints the modified contents to standard
output.
2023-06-12T13:07:18+01:00 sysutils/catatonit A signal-forwarding process manager for containers
A container init that is so simple it's effectively brain-dead. See
https://github.com/openSUSE/catatonit#readme for more details.
2023-06-30T17:46:12+00:00 x11/sandbar dwm-like bar for the river compositor
dwm-like bar for river.
2023-07-03T08:51:19+00:00 x11/watershot Simple Wayland-native screenshot tool
A simple Wayland-native screenshot tool inspired by Flameshot.
2023-07-22T07:51:54+02:00 security/py-cryptography-legacy Cryptographic recipes and primitives for Python developers
cryptography is a package which provides cryptographic recipes and primitives to
Python developers. Our goal is for it to be your "cryptographic standard
library". It supports Python 3.6+ and PyPy3 7.2+.

cryptography includes both high level recipes and low level interfaces to common
cryptographic algorithms such as symmetric ciphers, message digests, and key
derivation functions.
2023-07-21T18:06:36-05:00 biology/salmon Transcript-level quantification of RNA-seq from lightweight alignments
Salmon is a wicked-fast program to produce a highly-accurate,
transcript-level quantification estimates from RNA-seq data. Salmon
achieves is accuracy and speed via a number of different innovations,
including the use of quasi-mapping (accurate but fast-to-compute
proxies for traditional read alignments), and massively-parallel
stochastic collapsed variational inference. The result is a versatile
tool that fits nicely into many differnt pipelines.
2023-07-21T15:22:58-07:00 biology/btllib Bioinformatics Technology Lab common code library
Bioinformatics Technology Lab's common code library in C++.
2023-07-21T14:38:22-07:00 biology/seqwish Alignment to variation graph inducer
seqwish implements a lossless conversion from pairwise alignments between
sequences to a variation graph encoding the sequences and their alignments.
As input we typically take all-versus-all alignments, but the exact structure
of the alignment set may be defined in an application specific way. This
algorithm uses a series of disk-backed sorts and passes over the alignment and
sequence inputs to allow the graph to be constructed from very large inputs
that are commonly encountered when working with large numbers of noisy input
sequences. Memory usage during construction and traversal is limited by the use
of sorted disk-backed arrays and succinct rank/select dictionaries to record a
queryable version of the graph.
2023-07-21T13:34:58-07:00 devel/sdsl-lite Succinct Data Structure Library 2.0
The Succinct Data Structure Library (SDSL) is a powerful and flexible C++11
library implementing succinct data structures. In total, the library contains
the highlights of 40 research publications. Succinct data structures can
represent an object (such as a bitvector or a tree) in space close to the
information-theoretic lower bound of the object while supporting operations of
the original object efficiently. The theoretical time complexity of an operation
performed on the classical data structure and the equivalent succinct data
structure are (most of the time) identical.
2023-07-21T11:59:23-07:00 math/libdivsufsort Lightweight suffix-sorting library
libdivsufsort is a software library that implements a lightweight suffix array
construction algorithm.

This library provides a simple and an efficient C API to construct a suffix
array and a Burrows-Wheeler transformed string from a given string over a
constant-size alphabet. The algorithm runs in O(n log n) worst-case time using
only 5n+O(1) bytes of memory space, where n is the length of the string.
2023-07-21T10:18:03-07:00 textproc/vacuum OpenAPI/Swagger linter and quality analysis tool
Vacuum is an OpenAPI & Swagger linter.

vacuum will tell you what is wrong with your spec, why, where and how to fix it.
It will work at scale and is designed as a CLI (with a UI) and a library to be
consumed in other applications.
2023-07-20T23:02:52-07:00 math/py-qats Library for efficient processing and visualization of time series
QATS is a Python library and GUI for efficient processing and visualization
of time series.

QATS provides tools for:
* Import and export from/to various pre-defined time series file formats
* Signal processing
* Inferring statistical distributions
* Cycle counting using the Rainflow algorithm

It was originally created to handle time series files exported from SIMO and
RIFLEX. Now it also handles SIMA hdf5 (.h5) files, Matlab (version < 7.3)
.mat files, CSV files and more.

QATS also features a GUI which offers efficient and low threshold processing
and visualization of time series. It is perfect for inspecting, comparing and
reporting:
* time series
* power spectral density distributions
* peak and extreme distributions
* cycle distributions
2023-07-18T07:29:17-07:00 misc/py-npTDMS NumPy based module for reading TDMS files produced by LabView
npTDMS is a cross-platform Python package for reading and writing TDMS files
as produced by LabVIEW, and is built on top of the numpy package. Data is read
from TDMS files as numpy arrays, and npTDMS also allows writing numpy arrays
to TDMS files.

TDMS files are structured in a hierarchy of groups and channels. A TDMS file can
contain multiple groups, which may each contain multiple channels. A file, group
and channel may all have properties associated with them, but only channels have
array data.
2023-07-18T07:29:17-07:00 misc/py-thermocouples_reference Thermocouple emf reference functions
Python module containing calibration data and lookup functions for standard
thermocouples of types B, C, D, E, G, J, K, M, N, P, R, S, T, and some less
standard types too.
2023-07-18T07:29:17-07:00 misc/py-pymatreader Convenient reader for Matlab mat files
pymatreader is Python module to read Matlab files. This module works with both
the old (< 7.3) and the new (>= 7.3) HDF5 based format. The output should be
the same for both kinds of files.
2023-07-20T13:48:17+02:00 databases/postgresql-idn PostgreSQL extension for libidn2
At a fundamental level, this extension grants access to a number of
functions provided by the libidn and libidn2 libraries. Not all of the
functions provided by these libraries are exposed.

Whenever possible, the code will transform the encoding of the data in
the database to UTF-8 before further processing.
2023-07-18T07:21:39-07:00 misc/py-pyqir PyQIR parses, generates, evaluates Quantum Intermediate Representation
PyQIR is a set of APIs for generating, parsing, and evaluating
Quantum Intermediate Representation (QIR).
2023-07-18T07:02:44-07:00 devel/outcome C++14 library for reporting and handling function failures
Outcome is a C++14 library for reporting and handling function failures.
It can be used as a substitute for, or a complement to, the exception handling
mechanism.

One use case is for contexts where using C++ exception handling is unsuitable
for different reasons:
* The high relative cost of throwing and catching a C++ exception.
* Making some or all control paths explicitly detailed to aid code correctness
auditing, as opposed to having hidden control paths caused by exceptions
potentially thrown from any place.
* Company policy to compile with exceptions disabled.
* Maintaining a code base that was never designed with exception-safety in mind.
* Parts of the programs/frameworks that themselves implement exception handling
and cannot afford to use exceptions, like propagating failure reports across
threads, tasks, fibers.
2023-07-18T06:55:24-07:00 math/clad Automatic differentiation for C/C++
Clad enables automatic differentiation (AD) for C++. It is based on LLVM
compiler infrastructure and is a plugin for Clang compiler. Clad is based on
source code transformation. Given C++ source code of a mathematical function, it
can automatically generate C++ code for computing derivatives of the function.
It supports both forward-mode and reverse-mode AD.Clad has extensive coverage of
modern C++ features and a robust fallback and recovery system in place.
2023-07-17T20:43:22+00:00 security/monocypher Compact cryptographic library in C
Monocypher is an easy to use crypto library. It is:

- Small. Sloccount counts about 1700 lines of code, small enough to
allow audits. The binaries are under 65KB.

- Easy to deploy. Just add monocypher.c and monocypher.h to your
project. They compile as C99 or C++, have no dependency, and
are dedicated to the public domain.

- Easy to use. The API is small, consistent, and cannot fail
on correct input.

- Fast. The primitives are fast to begin with, and performance
wasn't needlessly sacrificed. Monocypher holds up pretty well
against Libsodium, despite being closer in size to TweetNaCl.
2023-07-17T10:58:21+02:00 devel/py-pytest-freezer Pytest plugin providing a fixture interface for freezegun
Pytest plugin providing a fixture interface for freezegun.

This is a dropin replacement for py-pytest-freezegun.
2023-07-16T15:56:15-07:00 ftp/pget Fast, resumable file download client
pget performs multi-connection download using parallel requests.

Features:
* Fast
* Resumable
* Cross-compiled (windows, linux, macOS)
2023-07-16T14:54:52-07:00 biology/locarna LocARNA provides several tools for the structural analysis of RNA
LocARNA is a collection of alignment tools for the structural analysis of RNA.
Given a set of RNA sequences, LocARNA simultaneously aligns and predicts common
structures for your RNAs. In this way, LocARNA performs Sankoff-like alignment
and is in particular suited for analyzing sets of related RNAs without known
common structure.

LocARNA distinguishes itself from many other Sankoff-style multiple alignment
programs by its performance and low memory complexity, high accuracy, and
richness of features. As unique features, it offers structure-local alignment,
flexible structure and anchor constraints, and provides efficient computation of
reliabilities in sequence-structure alignment. The package offers a robust core
of features and is used as experimental platform for the incorporation of new
features in RNA sequence-structure alignment.
2023-07-16T12:47:27+02:00 devel/magic_enum Header-only C++17 library provides static reflection for enums
Header-only C++17 library provides static reflection for enums, work
with any enum type without any macro or boilerplate code.
2023-07-15T21:37:24-07:00 textproc/tokay Programming language designed for ad-hoc parsing, inspired by awk
Tokay is a programming language to quickly implement solutions for text
processing problems. This can either be just simple data extractions, but also
parsing entire structures or parts of it, and turning information into
structured parse trees or abstract syntax trees for further processing.

Therefore, Tokay is both a tool and language for simple one-liners, but can also
be used to implement code-analyzers, refactoring tools, interpreters, compilers
or transpilers. Tokay's own language parser is implemented in Tokay itself.

Tokay is inspired by awk, has syntactic and semantic flavours of Python and
Rust, but also follows its own philosophy, ideas and design principles.
Thus, it isn't compareable to other languages or projects, and is a language on
its own.
2023-07-15T18:51:50-07:00 math/kalc Calculator for real and complex numbers, 2d/3d graphing, etc
kalc is a calculator for complex numbers, 2d/3d graphing, arbitrary precision,
vector, cli calculator with real-time output.
2023-07-15T18:13:44-07:00 devel/linenoise Small self-contained alternative to readline and libedit
linenoise is a minimal, zero-config, BSD licensed, readline replacement used
in Redis, MongoDB, Android and many other projects.

Features:
* Single and multi line editing mode with the usual key bindings implemented.
* History handling.
* Completion.
* Hints (suggestions at the right of the prompt as you type).
* Multiplexing mode, with prompt hiding/restoring for asynchronous output.
* About ~850 lines (comments and spaces excluded) of BSD license source code.
* Only uses a subset of VT100 escapes (ANSI.SYS compatible).
2023-07-15T16:51:21+02:00 devel/py-click-help-colors Colorization of help messages in Click
Colorization of help messages in Click.
2023-07-15T14:48:19+02:00 sysutils/rust-findutils Rust implementation of findutils
Rust implementation of GNU findutils.
2023-07-14T10:21:37-04:00 graphics/krita-gmic-plugin Krita native plugin for G'MIC
Native Krita plugin for the image processing framework G'MIC.

More than 500 filters are already available, sorted by category
(Artistic, Black & white, Colors, Contours, Deformations, Degradations,
Details, Film emulation, Frames, Layers, Light & shadows, Patterns,
Rendering, Repair, Sequences, etc.).
2023-07-13T00:45:47-07:00 devel/evcxr-jupyter Jupyter Evaluation Context for Rust
evcxr is an evaluation context for Rust.
This project consists of several related crates (parts):
* evcxr_jupyter: Axia Jupyter Kernel
* evcxr_repl: a Rust REPL
* etc
2023-07-12T23:44:16-07:00 misc/py-synced-collections Interact with persistent key-value stores using Pythonic abstractions
The synced_collections package provides Pythonic abstractions over various
underlying data stores, presenting APIs that behave like standard built-in
Python collections like dicts. synced_collections form the backbone of
signac's data and metadata storage, but may be used just as easily outside
of signac. For instance, users wishing to access a JSON file on disk like a
dictionary and automatically persist all changes could use the
synced_collections.JSONDict.
2023-07-11T12:40:35+00:00 x11-wm/emwm Enhanced Motif Window Manager
EMWM is a fork of the Motif Window Manager with fixes and enhancements. It
provides compatibility with current xorg extensions and applications, without
changing the way the window manager looks and behaves. This includes support for
multi-monitor setups trough Xinerama/Xrandr, UFT-8 support with Xft fonts, and
overall better compatibility with software that requires Extended Window Manager
Hints.
2023-07-10T18:44:10-07:00 biology/mashmap Fast approximate aligner for long DNA sequences
MashMap implements a fast and approximate algorithm for computing local
alignment boundaries between long DNA sequences. It can be useful for mapping
genome assembly or long reads (PacBio/ONT) to reference genome(s). Given a
minimum alignment length and an identity threshold for the desired local
alignments, Mashmap computes alignment boundaries and identity estimates using
k-mers. It does not compute the alignments explicitly, but rather estimates an
unbiased k-mer based Jaccard similarity using a combination of minmers (a novel
winnowing scheme) and MinHash. This is then converted to an estimate of sequence
identity using the Mash distance. An appropriate k-mer sampling rate is
automatically determined using the given minimum local alignment length and
identity thresholds.
2023-07-10T17:29:58-07:00 math/hyperdeal Finite-element library for partial differential equations
hyper.deal is an efficient, matrix-free finite-element library for solving
partial differential equations in two to six dimensions with high-order
discontinuous Galerkin methods. It builds upon the low-dimensional
finite-element library deal.II to create low-dimensional meshes and to
operate on them individually. We combine these meshes via a tensor product
on the fly and provide new special-purpose highly optimized matrix-free
functions.
2023-07-10T13:04:45-04:00 security/gpgme-qt-headers Shared headers for the Gpgme Qt bindings
2023-07-10T09:44:40-07:00 lang/prql Language for transforming data: powerful, pipelined SQL replacement
PRQL is a modern language for transforming data - a simple, powerful, pipelined
SQL replacement. Like SQL, it's readable, explicit and declarative. Unlike SQL,
it forms a logical pipeline of transformations, and supports abstractions such
as variables and functions. It can be used with any database that uses SQL,
since it compiles to SQL.
2023-07-10T05:21:14+08:00 x11-toolkits/p5-Test-Tk Testing Tk widgets
Test::Tk aims to assist in the testing of Perl/Tk widgets.

createapp creates a MainWindow widget and places it in the variable $app. It
sets a timer with delay $delay to start the internal test routine.

starttesting launches the main loop and sets a timer with delay $delay to start
the internal test routine.

When testing is done the MainWindow is destroyed and the test script continues.

You can set a command line parameter show to test command on the command line.
eg perl -Mblib t/My-Test.t show. The application will not terminate so you can
visually inspect it.

It will perform two tests. You need to account for these when you set your
number of tests.

If you are not on Windows and no XServer is running, all tests will be skipped.
2023-07-09T18:10:53+08:00 devel/rubygem-language_server-protocol Language Server Protocol SDK
LanguageServer::Protocol provides a Language Server Protocol SDK for Ruby.
2023-07-09T18:10:52+08:00 devel/rubygem-aws-sdk-verifiedpermissions Official AWS Ruby gem for Amazon Verified Permissions
Official AWS Ruby gem for Amazon Verified Permissions.
2023-07-09T18:10:51+08:00 devel/rubygem-aws-sdk-codegurusecurity Official AWS Ruby gem for Amazon CodeGuru Security
Official AWS Ruby gem for Amazon CodeGuru Security.
2023-07-09T18:10:51+08:00 devel/rubygem-aws-sdk-appfabric Official AWS Ruby gem for AppFabric
Official AWS Ruby gem for AppFabric.
2023-07-09T18:10:50+08:00 www/py-httpx-cache Simple caching transport for httpx
httpx-cache is an implementation of the caching algorithms in httplib2 and
CacheControl for use with httpx transport object.
2023-07-09T18:10:47+08:00 textproc/py-uc-micro-py Micro subset of Unicode data files for linkify-it-py projects
uc.micro-py is a Python port of uc.micro. It provides micro subset of Unicode
data files ONLY for linkify-it-py projects needs.
2023-07-09T18:10:44+08:00 textproc/py-linkify-it-py Links recognition library with FULL unicode support
linkify-it-py is a Python port of linkify-it. It links recognition library with
FULL unicode support. Focused on high quality link patterns detection in plain
text.

Why it's awesome:
- Full unicode support, with astral characters!
- International domains support.
- Allows rules extension & custom normalizers.
2023-07-09T18:10:42+08:00 textproc/py-cyclonedx-python-lib Library for producing CycloneDX SBOM (Software Bill of Materials) files
This CycloneDX module for Python can generate valid CycloneDX bill-of-material
document containing an aggregate of all project dependencies. CycloneDX is a
lightweight BOM specification that is easily created, human-readable, and simple
to parse.
2023-07-09T18:10:39+08:00 security/py-httpx-auth Authentication for HTTPX
httpx-auth provides authentication classes to be used with httpx authentication
parameter.
2023-07-09T18:15:49+08:00 security/py-certomancer PKI testing tool
Quickly construct, mock & deploy PKI test configurations using simple
declarative configuration. Includes CRL, OCSP and time stamping service
provisioning.
2023-07-09T18:10:33+08:00 math/py-scikit-fem Simple finite element assemblers
scikit-fem is a pure Python library for performing finite element assembly. Its
main purpose is the transformation of bilinear forms into sparse matrices and
linear forms into vectors.

The library
- has minimal dependencies
- contains no compiled code
- supports one-dimensional, triangular, quadrilateral, tetrahedral and
hexahedral finite elements
- includes special elements such as Raviart-Thomas, Nedelec, MINI,
Crouzeix-Raviart, Argyris, ...
2023-07-09T18:10:29+08:00 devel/py-scikit-base Base classes for sklearn-like parametric objects
skbase provides base classes for creating scikit-learn-like parametric objects,
along with tools to make it easier to build your own packages that follow these
design patterns.
2023-07-09T18:10:28+08:00 devel/py-rpds-py Python bindings to Rust persistent data structures (rpds)
Python bindings to the Rust rpds crate.

What's here is quite minimal (in transparency, it was written initially to
support replacing pyrsistent in the referencing library). If you see something
missing (which is very likely), a PR is definitely welcome to add it.

Methods in general are named similarly to their rpds counterparts (rather than
pyrsistent's conventions, though probably a full drop-in pyrsistent-compatible
wrapper module is a good addition at some point).
2023-07-09T18:10:27+08:00 devel/py-referencing JSON Referencing + Python
referencing is an implementation-agnostic implementation of JSON reference
resolution.

In other words, a way for e.g. JSON Schema tooling to resolve the $ref keyword
across all drafts without needing to implement support themselves.
2023-07-09T18:10:27+08:00 devel/py-pydantic-extra-types Extra Pydantic types
Pydantic Extra Types is a place for pydantic types that probably shouldn't exist
in the main pydantic lib.
2023-07-09T18:10:26+08:00 devel/py-pydantic2 Data validation using Python type hints
Pydantic provides data validation using Python type hints.

Fast and extensible, Pydantic plays nicely with your linters/IDE/brain. Define
how data should be in pure, canonical Python 3.7+; validate it with Pydantic.
2023-07-09T18:10:25+08:00 devel/py-py-serializable Library for serializing and deserializing Python Objects to and from JSON and XML
This Pythonic library provides a framework for serializing/deserializing Python
classes to and from JSON and XML.

It relies upon the use of Python Properties in your Python classes.
2023-07-09T18:10:24+08:00 devel/py-pip-requirements-parser Mostly correct pip requirements parsing library
pip-requirements-parser is a mostly correct pip requirements parsing library ...
because it uses pip's own code!
2023-07-09T18:10:24+08:00 devel/py-pip-audit Tool for scanning Python environments for known vulnerabilities
pip-audit is a tool for scanning Python environments for packages with known
vulnerabilities. It uses the Python Packaging Advisory Database
(https://github.com/pypa/advisory-database) via the PyPI JSON API as a source of
vulnerability reports.
2023-07-09T18:10:23+08:00 devel/py-pdm-autoexport PDM plugin to sync the exported files with the project file
pdm-autoexport is a PDM plugin to sync the exported files with the project file.
2023-07-09T18:10:22+08:00 devel/py-jsonschema-specifications JSON Schema meta-schemas and vocabularies, exposed as a Registry
JSON support files from the JSON Schema Specifications (metaschemas,
vocabularies, etc.), packaged for runtime access from Python as a
referencing-based Schema Registry.
2023-07-09T18:10:21+08:00 devel/py-annotated-types Reusable constraint types to use with typing.Annotated
PEP-593 added typing.Annotated as a way of adding context-specific metadata to
existing types, and specifies that Annotated[T, x] should be treated as T by any
tool or library without special logic for x.

annotated-types provides metadata objects which can be used to represent common
constraints such as upper and lower bounds on scalar values and collection
sizes, a Predicate marker for runtime checks, and descriptions of how we intend
these metadata to be interpreted. In some cases, we also note alternative
representations which do not require this package.
2023-07-09T18:10:21+08:00 devel/py-aiorwlock Read write lock for asyncio
aiorwlock provides read write lock for asyncio . A RWLock maintains a pair of
associated locks, one for read-only operations and one for writing. The read
lock may be held simultaneously by multiple reader tasks, so long as there are
no writers. The write lock is exclusive.

Whether or not a read-write lock will improve performance over the use of a
mutual exclusion lock depends on the frequency that the data is read compared to
being modified. For example, a collection that is initially populated with data
and thereafter infrequently modified, while being frequently searched is an
ideal candidate for the use of a read-write lock. However, if updates become
frequent then the data spends most of its time being exclusively locked and
there is little, if any increase in concurrency.
2023-07-09T18:10:20+08:00 math/tinymt Tiny Mersenne Twister
Tiny Mersenne Twister(TinyMT) is a pseudo random number generators whose periods
are 2^127-1.
2023-07-08T14:34:29-05:00 x11-toolkits/qt6pas Qt6 binding for FreePascal
Provide a Qt6 binding for FreePascal that may be of use to provide the Lazarus
LCL library with a Qt interface
2023-07-07T09:35:00-05:00 sysutils/devd-mount Automount tool utilizing devd notifications
devd-mount(8) is a devd(8) based automounter for FreeBSD. It supports
most popular filesystems such as exFAT, ISO9660, UDF, and FreeBSD's
native UFS. The devd-mount script mounts recognized filesystems and
invokes a specified command (typically qmediamanager) with the mount
point, device, and filesystem type as optional arguments.
2023-07-07T08:37:33-05:00 biology/bifrost Parallel construction, indexing and querying of de Bruijn graphs
Bifrost is a tool and API for parallel construction, indexing and
querying of colored and compacted de Bruijn graphs from FASTA/FASTQ
DNA/RNA sequence files.
2023-07-07T09:18:31+09:00 textproc/adoc-mode.el Major-mode for editing AsciiDoc files in Emacs
adoc-mode is an Emacs major mode for editing AsciiDoc files. It
emphasizes on the idea that the document is highlighted so it pretty
much looks like the final output. What must be bold is bold, what must
be italic is italic etc. Meta characters are naturally still visible,
but in a faint way, so they can be easily ignored.
2023-07-06T15:37:48+02:00 sysutils/fastfetch Like neofetch, but much faster because written in C
Fastfetch is a neofetch-like tool for fetching system information and
displaying them in a pretty way. It is written mainly in C, with performance
and customizability in mind. Currently, Linux, Android, FreeBSD, MacOS and
Windows 7+ are supported.
2023-07-02T20:46:13+03:00 devel/rubygem-google-protobuf323 Ruby extension to Google Protocol Buffers
rubygem-google-protobuf is a Ruby extension that implements Protocol Buffers
functionality. It makes use of generated Ruby code that defines message and enum
types in a Ruby DSL. You may write definitions in this DSL directly, but we
recommend using protoc's Ruby generation support with .proto files. The build
process in this directory only installs the extension; you need to install
protoc as well to have Ruby code generation functionality.
2023-07-02T20:46:13+03:00 devel/rubygem-aws-sdk-s31126 Official AWS Ruby gem for Amazon Simple Storage Service (Amazon S3)
Official AWS Ruby gem for Amazon Simple Storage Service (Amazon S3).
2023-07-02T20:46:13+03:00 devel/rubygem-aws-sdk-core3175 AWS SDK for Ruby - Core
Provides API clients for AWS. This gem is part of the official AWS SDK for
Ruby.
2023-07-06T07:44:54+01:00 devel/R-cran-decor Retrieve Code Decorations
Retrieves code comment decorations for C++ languages of the form
'\\ [[xyz]]', which are used for automated wrapping of C++ functions.
2023-06-30T17:41:46-04:00 net/py-anonfile Unofficial library that wraps the anonfile.com REST API
anonfile is an unofficial Python API created to make uploading and
downloading files from <anonfiles.com> simple and effective for
programming in Python. The goal of the project is to create an
intuitive library for anonymous file sharing.
2023-06-30T16:41:09-04:00 sysutils/gh-md-toc Easy TOC creation for GitHub README.md
gh-md-toc (or github-markdown-toc) is a TOC (Table of Content)
generator for a README.md or a GitHub wiki page without installing
additional software.
2023-05-25T17:53:31+02:00 databases/postgresql16-server PostgreSQL is the most advanced open-source database available anywhere
PostgreSQL is a sophisticated Object-Relational DBMS, supporting
almost all SQL constructs, including subselects, transactions, and
user-defined types and functions. It is the most advanced open-source
database available anywhere. Commercial Support is also available.

The original Postgres code was the effort of many graduate students,
undergraduate students, and staff programmers working under the direction of
Professor Michael Stonebraker at the University of California, Berkeley. In
1995, Andrew Yu and Jolly Chen took on the task of converting the DBMS query
language to SQL and created a new database system which came to known as
Postgres95. Many others contributed to the porting, testing, debugging and
enhancement of the Postgres95 code. As the code improved, and 1995 faded into
memory, PostgreSQL was born.

PostgreSQL development is presently being performed by a team of Internet
developers who are now responsible for all current and future development. The
development team coordinator is Marc G. Fournier (scrappy@PostgreSQL.ORG).
Support is available from the PostgreSQL developer/user community through the
support mailing list (questions@PostgreSQL.ORG).

PostgreSQL is free and the complete source is available.
2023-05-25T17:53:31+02:00 databases/postgresql16-pltcl Module for using Tcl to write SQL functions
2023-05-25T17:53:31+02:00 databases/postgresql16-plpython Module for using Python to write SQL functions
PL/Python allows one to write PostgeSQL stored functions and
procedures in Python (http://www.python.org/).

This software is part of the standard PostgreSQL distribution.
2023-05-25T17:53:31+02:00 databases/postgresql16-plperl Write SQL functions for PostgreSQL using Perl5
2023-05-25T17:53:31+02:00 databases/postgresql16-pgtcl
2023-05-25T17:53:31+02:00 databases/postgresql16-docs The PostgreSQL documentation set
2023-05-25T17:53:31+02:00 databases/postgresql16-contrib The contrib utilities from the PostgreSQL distribution
This is the port for all stuff that comes in the contrib subtree of
the postgresql distribution. This subtree contains porting tools,
analysis utilities, and plug-in features that are not part of the core
PostgreSQL system, mainly because they address a limited audience or
are too experimental to be part of the main source tree. This does
not preclude their usefulness.

Each subdirectory contains a README file with information about the
module. Some directories supply new user-defined functions, operators,
or types. After you have installed the files you need to register the
new entities in the database system by running the commands in the
supplied .sql file. For example,

$ psql -d dbname -f module.sql

The .sql files are installed into /usr/local/share/postgresql/contrib

For more information, please see
/usr/local/share/doc/postgresql/contrib/README*

This software is part of the standard PostgreSQL distribution.
2023-05-25T17:53:31+02:00 databases/postgresql16-client PostgreSQL database (client)
2023-07-05T11:51:47+02:00 devel/ocaml-sexplib0 OCaml library for working with S-expressions
This library contains functionality for parsing and pretty-printing
S-expressions. In addition to that it contains an extremely useful
preprocessing module for Camlp4, which can be used to automatically
generate code from type definitions for efficiently converting
OCaml-values to S-expressions and vice versa. In combination with the
parsing and pretty-printing functionality this frees the user from
having to write his own I/O-routines for data structures he defines.
Possible errors during automatic conversions from S-expressions to
OCaml-values are reported in a very human-readable way. Another module
in the library allows you to extract and replace sub-expressions in
S-expressions.
2023-07-04T20:22:54-07:00 devel/qtutilities Common Qt related C++ classes such as dialogs, widgets, models
Common Qt related C++ classes and routines such as dialogs, widgets and models.
2023-07-04T13:22:58-07:00 devel/cpp-utilities Common C++ classes such as argument parser, IO, conversion utilities
cpp-utilities contains useful C++ classes and routines such as argument parser,
IO and conversion utilities.
2023-07-04T12:47:39-07:00 lang/cairo Turing-complete language for creating provable programs
Cairo is the first Turing-complete language for creating provable programs for
general computation.
2023-07-04T02:07:11-07:00 science/salome-kernel Salome Project: Multi-physics simulations: Kernel
Kernel of the Salome project.

SALOME is an open-source software that provides a generic Pre- and
Post-Processing platform for numerical simulation.
2023-07-03T23:39:36-07:00 science/salome-configuration Salome Project: Multi-physics simulations: Configuration
Configuration part of the Salome project.

SALOME is an open-source software that provides a generic Pre- and
Post-Processing platform for numerical simulation.
2023-06-30T11:03:47-07:00 security/sssd-devel System Security Services Daemon
This project provides a set of daemons to manage access to remote
directories and authentication mechanisms, it provides an NSS and
PAM interface toward the system and a pluggable backend system to
connect to multiple different account sources. It is also the
basis to provide client auditing and policy services for projects
like FreeIPA. sssd also features caching, which can allow for
offline use to assist laptop users.
2023-07-03T13:21:25-07:00 x11/rio Hardware-accelerated GPU terminal emulator powered by WebGPU
Rio is a terminal built to run everywhere, as a native desktop applications
by Rust/WebGPU or even in the browser powered by WebAssembly/WebGPU.
2023-07-03T10:47:28-07:00 science/py-mp-api API for server for the Materials Project
mp-api contains the core client implementation for the updated
Materials Project API.
2023-07-03T10:46:03-07:00 science/py-emmet-core Materials API Toolkit for the Materials Project
emmet is the Materials API Toolkit for the Materials Project.
Emmet defines the core models, data pipelines, the API server,
and the convenience CLI.
2023-07-03T12:47:46+00:00 net/haproxy27 Reliable, high performance TCP/HTTP load balancer
HAProxy is a free, very fast and reliable solution offering high
availability, load balancing, and proxying for TCP and HTTP-based
applications. It is particularly suited for web sites crawling under
very high loads while needing persistence or Layer7 processing.
2023-07-02T22:49:19-07:00 science/py-mpcontribs-client Client library for MPContribs API on contribs-api.materialsproject.org
Client code for platform for materials scientists to contribute and disseminate
their materials data through Materials Project.
2023-07-02T19:49:09-07:00 mail/py-pyisemail Simple, robust email validation
pyIsEmail is a no-nonsense approach for checking whether that user-supplied
email address could be real.
2023-07-02T19:23:08-07:00 textproc/py-html2json Parse HTML to JSON
Convert a HTML webpage to JSON data using a template defined in JSON.
2023-06-25T23:51:35+00:00 multimedia/wl-screenrec High performance wlroots screen recording, featuring hardware encoding
High performance screen recorder for wlroots Wayland.

Uses dma-buf transfers to get surface, and uses the GPU to do both the
pixel format conversion and the encoding, meaning the raw video data
never touches the CPU, leaving it free to run your applications.

System Requirements:
* Wayland compositor supporting the following protocols:
* wlr-output-management-unstable-v1 (missing in hikari, cage, gamescope, kwinft)
* wlr-screencopy-unstable-v1 (missing in gamescope and kwinft)
Known working examples: sway, hyprland, wayfire, labwc.
* VA-API encoding:
* Intel iGPUs: libva-intel-media-driver or libva-intel-driver
* AMD/ATI GPUs: mesa-gallium-va
2023-07-02T13:26:00+00:00 x11/nwg-dock-hyprland GTK3-based dock for Hyprland
Configurable (with command line arguments and css) dock, written in
Go, aimed exclusively at the Hyprland Wayland compositor. It features
pinned buttons, client buttons and the launcher button. By default the
launcher starts nwg-drawer.
2023-07-02T13:47:55-07:00 devel/py-flatten-dict Utility for flattening and unflattening dict-like objects in Python
This package provides a function flatten() for flattening dict-like objects in
Python. It also provides some key joining methods (reducer), and you can choose
the reducer you want or even implement your own reducer. You can also invert the
resulting flat dict using unflatten().
2023-07-02T10:04:09-07:00 www/py-bravado Library for accessing Swagger-enabled APIs
Bravado is a Yelp maintained fork of digium/swagger-py for use with OpenAPI
Specification version 2.0 (previously known as Swagger).
2023-07-02T09:56:13-07:00 net/py-ephemeral-port-reserve Bind to ephemeral port, force TIME_WAIT state, and unbind it
ephemeral-port-reserve handles the situation when you need a networked program
to bind to a port that can't be hard-coded. Generally this is when you want to
run several of them in parallel; if they all bind to port 8080, only one of
them can succeed.
2023-07-02T09:39:16-07:00 www/py-bravado-core Library for adding Swagger support to clients and servers
bravado-core is a Python library that adds client-side and server-side
support for the OpenAPI Specification v2.0.
2023-07-02T09:05:43-07:00 science/py-pymatgen-analysis-alloys PyMatgen add-on library with classes useful for describing alloys
pymatgen-analysis-alloys is an add-on package for pymatgen intended to contain
useful classes for describing alloy systems and analyzing data relevant to these
systems. It currently contains the base classes and plotting functionality.
2023-07-02T08:43:17-07:00 devel/py-custodian Simple JIT job management framework in Python
Custodian is a simple, robust and flexible just-in-time (JIT) job management
framework written in Python. Using custodian, you can create wrappers that
perform error checking, job management and error recovery. It has a simple
plugin framework that allows you to develop specific job management workflows
for different applications.
2023-06-30T18:21:28+01:00 math/openscop Library for Data Exchange in Polyhedral Compilation Tools
OpenScop is an open specification that defines a file format and a set of
data structures to represent a static control part (SCoP for short),
i.e., a program part that can be represented in the polyhedral model.
The goal of OpenScop is to provide a common interface to various
polyhedral compilation tools in order to simplify their interaction.
2023-07-01T20:52:37+08:00 www/mediawiki140 Wiki engine used by Wikipedia
MediaWiki is the collaborative editing software that runs Wikipedia,
the free encyclopedia, and other projects.
It's designed to handle a large number of users and pages without imposing
too rigid a structure or workflow.
2023-07-01T12:04:53+02:00 multimedia/py-tartube GUI front-end for youtube-dl/yt-dlp, written in Python
Tartube is a GUI front-end for youtube-dl, yt-dlp and other compatible video
downloaders.

It is written in Python 3 / Gtk 3 and runs on MS Windows, Linux, BSD and
MacOS.
2023-07-01T11:50:10+02:00 audio/py-playsound Pure Python, single function module for playing sounds
Playsound is a pure Python, cross platform, single function module with no
dependencies for playing sounds.
2023-06-30T23:40:10+02:00 sysutils/backdown Tool to safely and ergonomically remove duplicate files
Backdown helps you safely and ergonomically remove duplicate files.

Its design is based upon the authors observation of frequent patterns
regarding build-up of duplicates with time, especially images and other
media files.

Finding duplicates is easy. Cleaning the disk when there are thousands
of them is the hard part. What Backdown brings is the easy way to select
and remove the duplicates you don't want to keep.
2023-06-30T09:21:01-07:00 devel/nano-signal-slot Pure C++17 signals and slots
nano-signal-slot is a C++ headers-only library for
signals and slots in C++17.
2023-06-30T08:58:01-07:00 audio/libremidi Modern C++ MIDI real-time & file I/O library
libremidi is a cross-platform C++17 library for real-time and MIDI file
input and output.

This is a fork based on two libraries:
* RtMidi
* ModernMIDI
2023-06-30T08:46:15-07:00 misc/qlcplus Q Light Controller Plus (QLC+)
Q Light Controller Plus (QLC+) is a free and cross-platform software to control
DMX or analog lighting systems like moving heads, dimmers, scanners etc. This
project is a fork of the great QLC project written by Heikki Junnila that aims
to continue the QLC development and to introduce new features.
2023-06-30T15:00:41+08:00 www/py-webtest Helper to test WSGI applications
py-WebTest is a helper to test WSGI applications, it wraps any WSGI application
and makes it easy to send test requests to that application, without starting up
an HTTP server. It provides convenient full-stack testing of applications
written with any WSGI-compatible framework.
2023-06-30T14:59:41+08:00 devel/rubygem-fiber-annotation Mechanism for annotating fibers
Fiber::Annotation provides a simple way to annotate what a fiber is currently
doing, useful for debugging, logging and tracing.
2023-06-30T14:59:41+08:00 devel/rubygem-aws-sdk-paymentcryptographydata Official AWS Ruby gem for Payment Cryptography Data Plane data
Official AWS Ruby gem for Payment Cryptography Data Plane data.
2023-06-30T14:59:40+08:00 devel/rubygem-aws-sdk-paymentcryptography Official AWS Ruby gem for Payment Cryptography Control Plane
Official AWS Ruby gem for Payment Cryptography Control Plane.
2023-06-30T14:59:39+08:00 textproc/py-mistune2 Fastest markdown parser in pure Python
Mistune is a fast yet powerful Python Markdown parser with renderers and
plugins.
2023-06-30T14:59:36+08:00 devel/py-nose3 nose extends unittest to make testing easier
nose3 is a drop-in fork of nose v1 that is compatible with Python 2.7 and Python
3.3-3.10 without using lib2to3 or other compatibility layer. It does not yet
support Python 3.11.

nose extends the test loading and running features of unittest, making it easier
to write, find and run tests.

By default, nose will run tests in files or directories under the current
working directory whose names include "test" or "Test" at a word boundary (like
"test_this" or "functional_test" or "TestClass" but not "libtest"). Test output
is similar to that of unittest, but also includes captured stdout output from
failing tests, for easy print-style debugging.

These features, and many more, are customizable through the use of plugins.
Plugins included with nose provide support for doctest, code coverage and
profiling, flexible attribute-based test selection, output capture and more.
More information about writing plugins may be found on in the nose API
documentation.
2023-06-30T14:59:35+08:00 devel/py-check-sdist Check the contents of an sdist vs git
Have you ever shipped broken sdists with missing files or possibly dirty sdists
with files that shouldn't have been there? Have you noticed that standards
compliant tools aren't making the same sdist that flit build is? Is hatchling
adding .DSStore files when you ship from your macOS? No matter what
build-backend you use, check-sdist can help!

Check-sdist builds an sdist and compares the contents with your Git repository
contents. It can even temporarily inject common junk files (like pycache files
or OS specific files) and help verify that those aren't getting bundled into
your sdist. If you are getting files you didn't expect or missing files you did
expect, consult your build backend's docs to see how to include or exclude
files.
2023-06-29T20:51:56-07:00 devel/quickcpplib Eliminate hassle when making state-of-the-art C++14-23 libraries
quickcpplib allows to eliminate all the tedious hassle when making
state-of-the-art C++14-23 libraries.
2023-06-29T19:35:12-07:00 misc/ola Open Lighting Architecture: framework for lighting control information
libartnet is an implementation of the ArtNet protocol.
ArtNet enables DMX512 and RDM data to be sent over IPv4 Networks.
ArtNet was first developed in 2002 and is widely supported by networked
devices in the entertainment industry.
2023-06-29T17:03:11-07:00 devel/mdspan Reference implementation of mdspan targeting C++23
The ISO-C++ proposal P0009 will add support for non-owning multi-dimensional
array references to the C++ standard library. This repository aims to provide
a production-quality implementation of the proposal as written (with a few
caveats, see below) in preparation for the addition of mdspan to the standard.
2023-06-29T16:51:10-07:00 math/perlinnoise Header-only Perlin noise library for modern C++
siv::PerlinNoise is a header-only Perlin noise library for modern C++
(C++17/20).
The implementation is based on Ken Perlin's Improved Noise Java class.
2023-06-29T16:49:58-07:00 misc/libartnet ArtNet protocol to transfer DMX data controlling theater equipment
libartnet is an implementation of the ArtNet protocol.
ArtNet enables DMX512 and RDM data to be sent over IPv4 Networks.
ArtNet was first developed in 2002 and is widely supported by networked
devices in the entertainment industry.
2023-06-28T19:34:53+02:00 converters/dos2unix DOS/Mac to Unix and vice versa text file format converter
This is an update of Benjamin Lin's implementations of dos2unix and
unix2dos. Benjamin Lin's implementations of dos2unix and unix2dos were
distributed via SunSITE.unc.edu (later MetaLab.unc.edu, now ibiblio)
and became part of several Linux distributions such as RedHat, Suse,
Gentoo, and others. This update includes all RedHat patches and fixes
several other problems. Internationalization has been added and ports
to DOS, Windows, Cygwin and OS/2 Warp have been made.

Features
* Native language support.
* Automatically skips binary and non-regular files.
* In-place, paired, or stdio mode conversion.
* Keep original file dates option.
* 7-bit and iso conversion modes like SunOS dos2unix.
* Conversion of Unicode UTF-16 files.
* Handles Unicode Byte Order Mark (BOM).
* Display file information.
* Secure.
2023-06-28T14:11:03+02:00 devel/cpu_rec_rs Determine which CPU architecture is used in a binary file
cpu_rec_rs is a Rust reimplementation of the original cpu_rec.
Why reimplement it?

- Performance
- Code simplification
- Rust practice

The original cpu_rec contains a lot of code necessary for experimenting
and updating the corpus.

If you want to play with various settings for prediction, please use
cpu_rec (github.com/airbus-seclab/cpu_rec).
2023-06-27T18:10:02+00:00 x11-wm/sawfish-pager Pager for Sawfish window manager
sawfish.wm.ext.pager is a C/Lisp extension that provides a functional
desktop pager for the Sawfish window manager.

A pager is a map of your desktop. As maps go, it shows not only the
visible part (your current viewport), but if you are so configured,
also the parts that extend beyond the sides of your screen. Also, if
you have more than one workspace, the pager will follow you to where
you are, or optionally show all workspaces at once. Of course you can
select viewports and windows, and also move or raise/lower the latter.
2023-06-27T16:10:43+09:00 devel/electron25 Build cross-platform desktop apps with JavaScript, HTML, and CSS
Build cross platform desktop apps with JavaScript, HTML, and CSS.

It's easier than you think.

If you can build a website, you can build a desktop app. Electron is a
framework for creating native applications with web technologies like
JavaScript, HTML, and CSS. It takes care of the hard parts so you can
focus on the core of your application.
2023-06-25T13:31:23-07:00 graphics/py-chart-studio Utilities for interfacing with plotly's Chart Studio
plotly.py is an interactive, open-source, and browser-based graphing library for
Python sparkles.

Built on top of plotly.js, plotly.py is a high-level, declarative charting
library. plotly.js ships with over 30 chart types, including scientific charts,
3D graphs, statistical charts, SVG maps, financial charts, and more.
2023-06-25T16:08:49+01:00 mail/dmarcts-report-parser Perl based tool to parse DMARC reports
A Perl based tool to parse DMARC reports, based on John Levine's rddmarc,
but extended by the following features:

Allow to read messages from an IMAP server and not only from
the local filesystem.

Store much more XML values into the database (for example the
missing SPF and DKIM results from the policy_evaluated section)
and also the entire XML for later reference.

Supports MySQL and PostgreSQL.

Needed database tables and columns are created automatically,
user only needs to provide a database. The database schema is
compatible to the one used by rddmarc, but extends it by
additional fields. Users can switch from rddmarc to
dmarcts-report-parser without having to do any changes to the
database by themselves.
2023-06-25T01:28:13-07:00 security/zlint X.509 certificate linter
ZLint is a X.509 certificate linter written in Go that checks for consistency
with standards (e.g. RFC 5280) and other relevant PKI requirements
(e.g. CA/Browser Forum Baseline Requirements).
2023-06-25T00:41:11-07:00 www/lzr Fast Go application scanner
LZR quickly detects and fingerprints unexpected services running on unexpected
ports by working with ZMap. LZR can detect up to 18 unique protocols
simultaneously with just two extra packets and can fingerprint over 35 different
protocols.
2023-06-25T00:03:20-07:00 www/zgrab2 Fast Go application scanner
ZGrab is a fast, modular application-layer network scanner designed for
completing large Internet-wide surveys. ZGrab is built to work with
ZMap (ZMap identifies L4 responsive hosts, ZGrab performs in-depth, follow-up
L7 handshakes). Unlike many other network scanners, ZGrab outputs detailed
transcripts of network handshakes (e.g., all messages exchanged in a TLS
handshake) for offline analysis.
2023-06-24T20:45:36+02:00 lang/perl5.38 Practical Extraction and Report Language
Perl is a language that combines some of the features of C, sed, awk and
shell. See the manual page for more hype. There are also many books
published by O'Reilly & Assoc. See pod/perlbook.pod for more
information.
2023-06-24T16:46:29+00:00 security/webtunnel-tor Pluggable Transport attempting to imitate web browsing based on HTTPT
WebTunnel is a pluggable transport for Tor that attempts to imitate web
browsing activities based on HTTPT, a Probe-Resistant Proxy.
2023-06-23T18:02:44-07:00 devel/py-pytest-subprocess Pytest plugin to fake subprocess for pytest
pytest-subprocess is a pytest plugin to fake subprocess.

The plugin adds the fake_process fixture (and fp as an alias). It can be used
it to register subprocess results so you won't need to rely on the real
processes. The plugin hooks on the subprocess.Popen(), which is the base for
other subprocess functions. That makes the subprocess.run(), subprocess.call(),
subprocess.check_call() and subprocess.check_output() methods also functional.
2023-06-23T00:04:54-07:00 math/py-jacobi Compute numerical derivatives
jacobi package for fast numerical derivatives for analytic functions with
arbitrary round-off error and error propagation.
2023-06-22T23:37:19-07:00 math/py-numba-stats Numba-accelerated implementations of common probability distributions
numba-stats provides numba-accelerated implementations of statistical functions
for common probability distributions.

* Uniform
* (Truncated) Normal
* Log-normal
* Poisson
* (Truncated) Exponential
* Student's t
* Voigtian
* Crystal Ball
* Generalised double-sided Crystal Ball
* Tsallis-Hagedorn, a model for the minimum bias pT distribution
* Q-Gaussian
* Bernstein density
* Cruijff density
2023-06-22T23:10:16-07:00 math/py-resample Resampling-based inference in Python
resample is a resampling-based inference in Python based on data resampling and
permutation.

Features:
* Bootstrap resampling: ordinary or balanced with optional stratification
* Extended bootstrap resampling: also varies sample size
* Parametric resampling: Gaussian, Poisson, gamma, etc.)
* Jackknife estimates of bias and variance of any estimator
* Compute bootstrap confidence intervals (percentile or BCa) for any estimator
* Permutation-based variants of traditional statistical tests (USP test of
independence and others)
* Tools for working with empirical distributions (CDF, quantile, etc.)
* Depends only on numpy and scipy
2023-06-22T22:56:10-07:00 textproc/py-unicodeitplus Converts simple LaTeX to an unicode approximation
unicodeitplus convert simple LaTeX into an unicode approximation and paste it
anywhere.
2023-06-22T18:23:47+03:00 www/rubygem-net-http011 HTTP client api for Ruby
Net::HTTP provides a rich library which can be used to build HTTP user-agents.
For more details about HTTP see RFC2616.

Net::HTTP is designed to work closely with URI. URI::HTTP#host, URI::HTTP#port
and URI::HTTP#request_uri are designed to work with Net::HTTP.

If you are only performing a few GET requests you should try OpenURI.
2023-06-22T18:23:47+03:00 security/rubygem-omniauth-shibboleth-redux OmniAuth strategy for Shibboleth
OmniAuth Shibboleth strategies for OmniAuth 2.x
2023-06-22T11:26:06+02:00 audio/sidplayfp Console SID/MUS player using sidplayfp
sidplayfp is a console C64 music player which uses the libsidplayfp
engine to provide the best SID listening experience.
2023-06-22T10:51:00+08:00 print/py-PyMuPDF Python bindings for the PDF toolkit and renderer MuPDF
PyMuPDF adds Python bindings and abstractions to MuPDF, a lightweight
PDF, XPS, and eBook viewer, renderer, and toolkit. Both PyMuPDF and
MuPDF are maintained and developed by Artifex Software, Inc.

MuPDF can access files in PDF, XPS, OpenXPS, CBZ, EPUB and FB2 (eBooks)
formats, and it is known for its top performance and exceptional rendering
quality.

With PyMuPDF you can access files with extensions like .pdf, .xps, .oxps,
.cbz, .fb2 or .epub. In addition, about 10 popular image formats can also
be handled like documents: .png, .jpg, .bmp, .tiff, etc.
2023-06-21T17:07:41+02:00 www/p5-Plack-Middleware-Headers Perl extension to modify HTTP response headers
This Plack::Middleware simplifies creation (set or append), deletion (unset),
and modification (set) of PSGI response headers. The modification can be
enabled based on response code (code) or existing response headers(when).
Use Plack::Middleware::Conditional to enable the middleware based in
request headers.
2023-06-19T18:37:46+02:00 cad/qspeakers Open source loudspeaker enclosure designer
QSpeakers is an open source DIY speakers enclosure design software written
in C++ with Qt for the UI. This program simulates common acoustical
enclosures behaviour in the mean to help users to design their own
loudspeaker systems.
2023-06-21T07:26:27+02:00 graphics/3d-ascii-viewer Viewer of 3D models in ASCII
3d-ascii-viewer-c is a program written in C that allows users to view 3D
models in ASCII. It supports Wavefront .obj files and provides an
example usage capture.

The program can be executed by passing any of the models in the models
folder as an argument.

The available models include Fox and ShibaInu models, as well as Tree
models.

This program is inspired by the ASCII luminescence and offers an
intuitive way of viewing 3D models in ASCII.
2023-06-20T19:37:42-07:00 math/py-pytensor Optimizing compiler for evaluating mathematical expressions
PyTensor is a fork of Aesara - a Python library that allows one to define,
optimize, and efficiently evaluate mathematical expressions involving
multi-dimensional arrays.

Features:
* A hackable, pure-Python codebase
* Extensible graph framework suitable for rapid development of custom operators
and symbolic optimizations
* Implements an extensible graph transpilation framework that currently provides
compilation via C, JAX, and Numba
* Based on one of the most widely-used Python tensor libraries: Theano
2023-06-20T18:51:44-07:00 devel/py-miniKanren Logic/relational programming in Python
miniKanren is an extensible, lightweight relational/logic programming DSL
written in pure Python.
2023-06-20T18:34:02-07:00 devel/py-etuples Python S-expression emulation using tuple-like objects
Python S-expression emulation using tuple-like objects.

In computer programming, an S-expression (or symbolic expression, abbreviated
as sexpr or sexp) is an expression in a like-named notation for nested list
(tree-structured) data. S-expressions were invented for and popularized by the
programming language Lisp, which uses them for source code as well as data.
2023-06-20T18:16:29-07:00 devel/py-cons Implementation of Lisp/Scheme-like cons in Python
The cons package attempts to emulate the semantics of Lisp/Scheme's cons as
closely as possible while incorporating all the built-in Python sequence types.

In computer programming, cons is a fundamental function in most dialects of the
Lisp programming language. cons constructs memory objects which hold two values
or pointers to two values.
2023-06-20T18:06:48-07:00 math/py-logical-unification Logical unification in Python
Logical unification in Python, extensible via dispatch.

In logic and computer science, unification is an algorithmic process of solving
equations between symbolic expressions.
2023-06-19T23:02:26-07:00 devel/py-archspec Library to query system architecture
Archspec aims at providing a standard set of human-understandable labels for
various aspects of a system architecture like CPU, network fabrics, etc.
and APIs to detect, query and compare them.

This project grew out of Spack and is currently under active development. At
present it supports APIs to detect and model compatibility relationships among
different CPU microarchitectures.
2023-06-05T21:17:22+02:00 devel/shiboken6 Python binding generator for C++ libraries
Qt is a cross-platform application and UI framework for developers
using C++ or QML, a CSS/JavaScript-like language.

Qt Quick is a collection of technologies that are designed to help
developers create intuitive, modern, and fluid user interfaces.
2023-06-05T21:17:22+02:00 devel/pyside6 Python Qt bindings for Qt 6
PySide is the Python Qt bindings project, providing access to the complete
Qt 6 framework as well as to generator tools for rapidly generating
Python bindings for any C++ libraries.
2023-06-05T21:17:22+02:00 devel/pyside6-tools PySide6 development tools
PySide6 is the Python Qt 6 bindings project. This package contains the
PySide6 development tools.
2023-06-18T14:44:04+03:00 textproc/apache-solr8 High performance search server built using Lucene Java
Solr is an open source enterprise search server based on the Lucene
Java search library, with XML/HTTP and JSON APIs, hit highlighting,
faceted search, caching, replication, a web administration interface
and many more features. It runs in a Java servlet container such as
Tomcat.
2023-06-18T14:23:21-04:00 graphics/frei0r-plugins-cairo Frei0r ${SLAVE_PORT} plugins
2023-06-18T09:20:08-07:00 devel/py-aspectlib Aspect-oriented programming, monkey-patch and decorators library
aspectlib is an aspect-oriented programming, monkey-patch and decorators
library. It is useful when changing behavior in existing code is desired.
It includes tools for debugging and testing: simple mock/record and a
complete capture/replay framework.
2023-06-17T20:51:17-07:00 sysutils/cfengine322 Systems administration tool for networks
Cfengine is an automated suite of programs for configuring and
maintaining Unix-like computers. It has been used on computing arrays
of between 1 and 20,000 computers since 1993 by a wide range of
organizations. Cfengine is supported by active research and was the
first autonomic, hands-free management system for Unix-like operating
systems. Cfengine is an autonomic maintenance system not merely a
change management roll-out tool. Cfengine has a history of security
and adaptability.
2023-06-17T20:51:17-07:00 sysutils/cfengine-masterfiles322 cfengine sample policies for installations and upgrades
CFEngine 3 is a popular open source configuration management system.
Its primary function is to provide automated configuration and
maintenance of large-scale computer systems.

The repository is intended to provide a stable base policy for
installations and upgrades, and is used by CFEngine 3.6 and newer.
The port installs the repository as examples which should be copied by
the user to the masterfiles directory (usually /var/cfengine/masterfiles).
2023-04-29T23:18:32+00:00 x11/shikane Dynamic output configuration tool for Wayland compositors
A dynamic output configuration tool that automatically detects and configures
connected outputs based on a set of profiles.

Each profile specifies a set of outputs with additional parameters (e.g., mode).
A profile will be applied automatically if all specified outputs and modes can
be perfectly matched to the currently connected outputs and their capabilities.

This is a Wayland equivalent for tools like autorandr.
It aims to fully replace kanshi and add new features.
shikane works with Wayland compositors supporting version 3 of the
wlr-output-management protocol (e.g., compositors using wlroots v0.16).
2023-06-17T10:17:31+02:00 devel/py-time-machine Travel through time in your Python tests
time-machine is intended to combine the advantages of freezegun and libfaketime
Python modules. It works without LD_PRELOAD but still mocks the standard
library functions everywhere they may be referenced. It does so by modifying
the built-in functions at the C level, to point them through wrappers that
return different values when mocking. Normally in Python, built-in functions
are immutable, but time-machine overcomes this by using C code to replace their
function pointers.
2023-06-16T09:39:49-07:00 devel/py-types-python-dateutil Typing stubs for python-dateutil
This is a PEP 561 type stub package for the python-dateutil package.
It can be used by type-checking tools like mypy, pyright, pytype,
PyCharm, etc. to check code that uses python-dateutil.
2023-06-16T09:48:07-07:00 devel/py-types-retry Typing stubs for retry
This is a PEP 561 type stub package for the retry package. It can be used by
type-checking tools like mypy, pyright, pytype, PyCharm, etc. to check code
that uses retry.
2023-06-16T08:59:38-07:00 devel/py-diff-cover Run coverage and linting reports on diffs
Automatically find diff lines that need test coverage. Also finds diff lines
that have violations (according to tools such as pycodestyle, pyflakes, flake8,
or pylint). This is used as a code quality metric during code reviews.
2023-06-15T18:04:37+02:00 graphics/podofo09 PDF manipulation library and tools
PoDoFo is a library to work with the PDF file format. The name comes from the
first letter of PDF (Portable Document Format). A few tools to work with PDF
files are already included in the PoDoFo package.

The PoDoFo library is a free, portable C++ library which includes classes to
parse PDF files and modify their contents into memory. The changes can be
written back to disk easily. The parser can also be used to extract information
from a PDF file (for example the parser could be used in a PDF viewer). Besides
parsing PoDoFo includes also very simple classes to create your own PDF files.
All classes are documented so it is easy to start writing your own application
using PoDoFo.
2023-06-15T10:44:21+02:00 net/intel-iavf-kmod 40G and 100G FreeBSD Driver for Virtual Function for Intel NIC
This release includes the iavf FreeBSD Base Driver for Intel(R) Ethernet
Network Connections.

The iavf driver supports devices based on the following controllers:
* Intel Ethernet Controller E810-C
* Intel Ethernet Controller E810-XXV
* Intel Ethernet Connection E822-C
* Intel Ethernet Connection E822-L
* Intel Ethernet Connection E823-C
* Intel Ethernet Connection E823-L
* Intel Ethernet Controller I710
* Intel Ethernet Controller X710
* Intel Ethernet Controller XL710
* Intel Ethernet Network Connection X722
* Intel Ethernet Controller XXV710
* Intel Ethernet Controller V710
2023-06-14T16:22:35-05:00 biology/chip-seq Metaport for ChIP-Seq analysis
Metaport to install tools for typical ChIP-Seq analysis, including QC,
adapter trimming, alignment, and differential analysis.
2023-06-14T17:59:52+02:00 games/candycrisis Pure action and puzzle gaming
An exciting combination of pure action and puzzle gaming.

This is an unofficial source port of the old Mac game "Candy Crisis".
This version has an optional widescreen mode.
2023-06-14T15:28:42+01:00 shells/murex Shell designed for greater commandline productivity and safer shell scripts
Murex is a shell, like bash / zsh / fish / etc however Murex
supports improved features and an enhanced UX.

A non-exhaustive list features would include:

* Support for additional type information in pipelines, which can
be used for complex data formats like JSON or tables. Meaning
all of your existing UNIX tools to work more intelligently and
without any additional configuration.

* Usability improvements such as in-line spell checking, context
sensitive hint text that details a commands behavior before you
hit return, and auto-parsing man pages for auto-completions on
commands that don't have auto-completions already defined.

* Smarter handling of errors and debugging tools. For example
try/catch blocks, line numbers included in error messages,
STDOUT highlighted in red and script testing and debugging
frameworks baked into the language itself.
2023-06-14T14:45:59+02:00 sysutils/intel-epct Intel(R) Ethernet Port Configuration Tool
The Ethernet Port Configuration Tool (EPCT) is a command line utility that
allows users to change the link type of a device. The supported types are
defined within the adapter's NVM. This utility displays only the devices that
potentially support reconfiguration.
2023-06-14T13:00:04+02:00 sysutils/intel-nvmupdate-100g NVM Update Utility for Intel(R) 100G Ethernet Adapters
This package contains all the required files to update the NVM on the
Intel(R) Ethernet adapters in your system. It contains the NVMUpdate utility,
configuration file, updated NVM binaries, and required driver files.
2023-06-14T12:57:41+02:00 sysutils/intel-nvmupdate-10g NVM Update Utility for Intel(R) 10G Ethernet Adapters
This package contains all the required files to update the NVM on the
Intel(R) Ethernet adapters in your system. It contains the NVMUpdate utility,
configuration file, updated NVM binaries, and required driver files.
2023-06-14T12:29:57+02:00 sysutils/intel-nvmupdate-40g NVM Update Utility for Intel(R) 40G Ethernet Adapters
This package contains all the required files to update the NVM on the
Intel(R) Ethernet adapters in your system. It contains the NVMUpdate utility,
configuration file, updated NVM binaries, and required driver files.
2023-06-14T14:30:44+02:00 devel/py-jaraco.collections Python models and classes to supplement the stdlib ‘collections’
Models and classes to supplement the stdlib 'collections' module.

Highlights include:

* RangeMap: A mapping that accepts a range of values for keys.
* Projection: A subset over an existing mapping.
* KeyTransformingDict: Generalized mapping with keys transformed by a
function.
* FoldedCaseKeyedDict: A dict whose string keys are case-insensitive.
* BijectiveMap: A map where keys map to values and values back to their keys.
* ItemsAsAttributes: A mapping mix-in exposing items as attributes.
* IdentityOverrideMap: A map whose keys map by default to themselves unless
overridden.
* FrozenDict: A hashable, immutable map.
* Enumeration: An object whose keys are enumerated.
* Everything: A container that contains all things.
* Least, Greatest: Objects that are always less than or greater than any
other.
* pop_all: Return all items from the mutable sequence and remove them from
that sequence.
* DictStack: A stack of dicts, great for sharing scopes.
* WeightedLookup: A specialized RangeMap for selecting an item by weights.
2023-06-14T11:59:51+02:00 devel/py-pytest-services Fixtures and utility functions to run service processes for pytest
This Pytest plugin provides a set of fixtures and utility functions to start
service processes for your tests with pytest.
2023-06-13T19:10:02+02:00 net/intel-irdma-kmod RDMA FreeBSD* driver for Intel® Ethernet Controller E810
This release includes the FreeBSD RDMA Driver for Intel(R) Ethernet Network Connections.

The irdma driver supports devices based on the following controllers:
* Intel® Ethernet Controller E810-C
* Intel® Ethernet Controller E810-XXV
2023-06-12T17:26:57+02:00 devel/libkiwix Common code base for all Kiwix ports
Kiwix is an offline reader for web content archived in ZIM format. It is
particularly tailored towards Wikipedia and other wikis.

The Kiwix library contains the code shared by Kiwix ports on all supported
platforms.
2023-06-12T17:13:33+02:00 net/intel-ice-kmod Intel® Network Adapter Driver for E810 Series Devices
This release includes the ice FreeBSD Base Driver for Intel(R) Ethernet Network
Connections.

The ice driver supports devices based on the following controllers:
* Intel(R) Ethernet Controller E810-C
* Intel(R) Ethernet Controller E810-XXV
* Intel(R) Ethernet Connection E822-C
* Intel(R) Ethernet Connection E822-L
* Intel(R) Ethernet Connection E823-C
* Intel(R) Ethernet Connection E823-L
2023-06-12T16:55:14+02:00 net/intel-ixv-kmod 10G FreeBSD Base Driver Virtual Function for Intel(R) NIC
This release includes the 10 gigabit FreeBSD Base Driver for Intel(R) Network
Connection.

- ixgbe driver supports all 82599 and 82598EB-based 10 gigabit
network connections.
2023-06-12T10:39:36+02:00 graphics/catimg Insanely fast image printing in your terminal
catimg is a little program written in C with no dependencies that prints
images in terminal. It supports JPEG, PNG and GIF formats. This program
was originally a script that did the same by using ImageMagick convert.
2023-06-11T02:56:50+09:00 textproc/yamlfmt Simple command line tool for formatting yaml files
Simple and easy-to-use command line tool for formatting yaml files written in
Go language.
2023-06-10T13:59:03+02:00 www/php83-tidy
2023-06-10T13:59:03+02:00 www/php83-session
2023-06-10T13:59:03+02:00 www/php83-opcache
2023-06-10T13:59:03+02:00 www/mod_php83
2023-06-10T13:59:03+02:00 textproc/php83-xsl
2023-06-10T13:59:03+02:00 textproc/php83-xmlwriter
2023-06-10T13:59:03+02:00 textproc/php83-xmlreader
2023-06-10T13:59:03+02:00 textproc/php83-xml
2023-06-10T13:59:03+02:00 textproc/php83-simplexml
2023-06-10T13:59:03+02:00 textproc/php83-pspell
2023-06-10T13:59:03+02:00 textproc/php83-enchant
2023-06-10T13:59:03+02:00 textproc/php83-dom
2023-06-10T13:59:03+02:00 textproc/php83-ctype
2023-06-10T13:59:03+02:00 sysutils/php83-posix
2023-06-10T13:59:03+02:00 sysutils/php83-fileinfo
2023-06-10T13:59:03+02:00 security/php83-sodium
2023-06-10T13:59:03+02:00 security/php83-filter
2023-06-10T13:59:03+02:00 net/php83-sockets
2023-06-10T13:59:03+02:00 net/php83-soap
2023-06-10T13:59:03+02:00 net/php83-ldap
2023-06-10T13:59:03+02:00 net-mgmt/php83-snmp
2023-06-10T13:59:03+02:00 misc/php83-calendar
2023-06-10T13:59:03+02:00 math/php83-gmp
2023-06-10T13:59:03+02:00 math/php83-bcmath
2023-06-10T13:59:03+02:00 mail/php83-imap
2023-06-10T13:59:03+02:00 lang/php83 The ${PHP_MODNAME} shared extension for php
PHP, which stands for "PHP: Hypertext Preprocessor" is a widely-used Open
Source general-purpose scripting language that is especially suited for
Web development and can be embedded into HTML. Its syntax draws upon C,
Java, and Perl, and is easy to learn. The main goal of the language is to
allow web developers to write dynamically generated webpages quickly, but
you can do much more with PHP.
2023-06-10T13:59:03+02:00 lang/php83-extensions "meta-port" to install PHP extensions
This is a "meta-port" to install the extensions for PHP 8.0

Defaults to:
ctype, dom, filter, iconv, json, opcache, pdo, pdo_sqlite, phar, posix,
session, simplexml, sqlite3, tokenizer, xml, xmlreader and xmlwriter.
2023-06-10T13:59:03+02:00 graphics/php83-gd
2023-06-10T13:59:03+02:00 graphics/php83-exif
2023-06-10T13:59:03+02:00 ftp/php83-ftp
2023-06-10T13:59:03+02:00 ftp/php83-curl
2023-06-10T13:59:03+02:00 devel/php83-tokenizer
2023-06-10T13:59:03+02:00 devel/php83-sysvshm
2023-06-10T13:59:03+02:00 devel/php83-sysvsem
2023-06-10T13:59:03+02:00 devel/php83-sysvmsg
2023-06-10T13:59:03+02:00 devel/php83-shmop
2023-06-10T13:59:03+02:00 devel/php83-readline
2023-06-10T13:59:03+02:00 devel/php83-pcntl
2023-06-10T13:59:03+02:00 devel/php83-intl
2023-06-10T13:59:03+02:00 devel/php83-gettext
2023-06-10T13:59:03+02:00 devel/php83-ffi
2023-06-10T13:59:03+02:00 databases/php83-sqlite3
2023-06-10T13:59:03+02:00 databases/php83-pgsql
2023-06-10T13:59:03+02:00 databases/php83-pdo_sqlite
2023-06-10T13:59:03+02:00 databases/php83-pdo_pgsql
2023-06-10T13:59:03+02:00 databases/php83-pdo_odbc
2023-06-10T13:59:03+02:00 databases/php83-pdo_mysql
2023-06-10T13:59:03+02:00 databases/php83-pdo_firebird
2023-06-10T13:59:03+02:00 databases/php83-pdo_dblib
2023-06-10T13:59:03+02:00 databases/php83-pdo
2023-06-10T13:59:03+02:00 databases/php83-odbc
2023-06-10T13:59:03+02:00 databases/php83-mysqli
2023-06-10T13:59:03+02:00 databases/php83-dba
2023-06-10T13:59:03+02:00 converters/php83-mbstring
2023-06-10T13:59:03+02:00 converters/php83-iconv
2023-06-10T13:59:03+02:00 archivers/php83-zlib
2023-06-10T13:59:03+02:00 archivers/php83-zip
2023-06-10T13:59:03+02:00 archivers/php83-phar
2023-06-10T13:59:03+02:00 archivers/php83-bz2
2023-06-10T07:08:28-05:00 deskutils/qmediamanager GUI tool for managing removable media
QMediaManager is a GUI application for managing removable media. It is
meant to be launched by an automount service such as sysutils/automount
to provide the user options when removable media are inserted.
2023-06-10T07:05:07-05:00 sysutils/npmount Command line tool for non-privileged [un]mount
NPMount is a command-line tool to provide limited mount and unmount
capabilities to non-privileged users, such as mounting and unmounting
external media including optical discs and thumb drives.
2023-06-09T08:12:50+00:00 devel/tclap12 Verbose replacement for getopt (stable version)
TCLAP is a small, flexible library that provides a simple interface for
defining and accessing command line arguments.

It seems to do everything that getopt(3) can do. It is needed here as
a dependency for `www/envoy'.
2023-06-09T08:53:07+02:00 audio/audiowmark Audio and video watermarking tool
A sound file is read by the software, and a 128-bit message is stored in
a watermark in the output sound file. For human listeners, the files
typically sound the same.

However, the 128-bit message can be retrieved from the output sound
file. Our tests show, that even if the file is converted to mp3 or ogg
(with bitrate 128 kbit/s or higher), the watermark usually can be
retrieved without problems. The process of retrieving the message does
not need the original audio file (blind decoding).

Internally, audiowmark is using the patchwork algorithm to hide the data
in the spectrum of the audio file. The signal is split into 1024 sample
frames. For each frame, some pseoudo-randomly selected amplitudes of the
frequency bands of a 1024-value FFTs are increased or decreased
slightly, which can be detected later.
2023-06-09T01:20:21-04:00 security/sequoia-sq Sequoia-PGP command line tool
Sequoia-PGP is an implementation of OpenPGP in Rust. It includes a
suite of library crates, which are meant to be used from applications.
This crate provides the sq command line application. sq is aimed
at command line users as a way to use OpenPGP conveniently from the
command line.
2023-05-28T18:15:53+02:00 net/py-bonsai Module for handling LDAP operations in Python
This module uses libldap2 on Unix platforms and WinLDAP on Microsoft Windows.
LDAP entries are mapped to a special Python case-insensitive dictionary,
tracking the changes of the dictionary to modify the entry on the server easily.
2023-06-04T07:32:21+02:00 sysutils/scanbd Scanner button daemon
scanbd is daemon that listens for scanner button presses and can run scripts.

From the project page:

scanbd is a scanner button daemon. It polls the scanner buttons
looking for buttons pressed or function knob changes or other scanner
events as paper inserts / removals and at the same time allows also
scan-applications to access the scanners. If buttons are pressed,
etc., various actions can be submitted (scan, copy, email, ...) via
action scripts. The function knob values are passed to the
action-scripts as well. Scan actions are also signaled via dbus. This
can be useful for foreign applications. Scans can also be triggered
via dbus from foreign applications. On platforms which support
signaling of dynamic device insertion / removal (libudev, dbus, hal)
scanbd supports this as well. scanbd can use all sane-backends or some
special backends from the (old) scanbuttond project. Supported
platforms: Linux, FreeBSD, NetBSD, OpenBSD
2023-06-07T16:37:53-07:00 graphics/py-fury Free Unified Rendering in Python
FURY is a free and open-source software library for Scientific Visualization
and 3D animations.
2023-06-07T16:08:56-07:00 graphics/py-pygltflib Library for managing 3D objects in Khronos Group gltf, gltf2 formats
pygltflib is a library for reading, writing and handling GLTF files.

It supports the entire specification, including materials and animations.

Main features are:
* GLB and GLTF support
* Buffer data conversion
* Extensions
* All attributes are type-hinted
2023-06-07T19:16:12+01:00 security/py-certbot-dns-standalone Standalone DNS Authenticator plugin for Certbot
Standalone DNS Authenticator plugin for Certbot (security/py-certbot).

This is a plugin that uses an integrated DNS server to respond to the
_acme-challenge records, so the domain's records do not have to be modified.
2023-06-07T16:25:59+02:00 sysutils/sake Task runner for local and remote hosts
sake is a command runner for local and remote hosts. You define servers
and tasks in a sake.yaml config file and then run the tasks on the
servers.
2023-06-07T20:59:51+08:00 www/angie Efficient, powerful and scalable reverse proxy and web server
Actively developing fork of nginx aiming to keep it great
with brand new extra functionality.
2023-06-07T14:10:23+02:00 devel/py-looseversion Python extension for comparing version strings
A backwards/forwards-compatible fork of distutils.version.LooseVersion, for
times when PEP-440 isn't what you need.

The goal of this package is to be a drop-in replacement for the original
LooseVersion. It implements an identical interface and comparison logic to
LooseVersion. The only major change is that a looseversion.LooseVersion is
comparable to a distutils.version.LooseVersion, which means tools should not
need to worry whether all dependencies that use LooseVersion have migrated.
2023-06-07T10:24:09+02:00 archivers/bzip3 Better and stronger spiritual successor to BZip2
A better, faster and stronger spiritual successor to BZip2. Features
higher compression ratios and better performance thanks to a order-0
context mixing entropy coder, a fast Burrows-Wheeler transform code
making use of suffix arrays and a RLE with Lempel Ziv+Prediction pass
based on LZ77-style string matching and PPM-style context modeling.
2023-06-06T14:09:16-07:00 cad/yosys-systemverilog SystemVerilog support for Yosys
yosys-systemverilog is a YoSys add-on that contains all moving parts needed to
get SystemVerilog support enabled in Yosys.
2023-06-06T11:08:55-07:00 security/krb5-121 MIT implementation of RFC 4120 network authentication service
Kerberos V5 is an authentication system developed at MIT.
Abridged from the User Guide:
Under Kerberos, a client sends a request for a ticket to the
Key Distribution Center (KDC). The KDC creates a ticket-granting
ticket (TGT) for the client, encrypts it using the client's
password as the key, and sends the encrypted TGT back to the
client. The client then attempts to decrypt the TGT, using
its password. If the client successfully decrypts the TGT, it
keeps the decrypted TGT, which indicates proof of the client's
identity. The TGT permits the client to obtain additional tickets,
which give permission for specific services.
Since Kerberos negotiates authenticated, and optionally encrypted,
communications between two points anywhere on the internet, it
provides a layer of security that is not dependent on which side of a
firewall either client is on.
The Kerberos V5 package is designed to be easy to use. Most of the
commands are nearly identical to UNIX network programs you are already
used to. Kerberos V5 is a single-sign-on system, which means that you
have to type your password only once per session, and Kerberos does
the authenticating and encrypting transparently.

Jacques Vidrine <n@nectar.com>
2023-05-21T16:23:40-04:00 net/intel-igb-kmod NIC Driver for Intel(R) 82575/6 and 82580-Based cards
This release includes the gigabit FreeBSD igb(4) drivers for Intel(R) 82575/6
and 82580-Based Gigabit Network Connections.
2023-06-06T03:40:02+02:00 sysutils/dutree Tool to analyze file system usage written in Rust
A tool to analyze file system usage written in Rust.

Features:
- coloured output, according to the LS_COLORS environment variable.
- display the file system tree
- ability to aggregate small files
- ability to exclude files or directories
- ability to compare different directories
- fast, written in Rust
2023-06-06T02:18:20+08:00 textproc/rubygem-nokogiri114 HTML, XML, SAX, and Reader parser
* XPath support for document searching
* CSS3 selector support for document searching
* XML/HTML builder
* Drop in replacement for Hpricot (though not bug for bug)

Nokogiri parses and searches XML/HTML very quickly, and also has
correctly implemented CSS3 selector support as well as XPath support.
2023-06-06T02:18:18+08:00 devel/rubygem-aws-sdk-s31122 Official AWS Ruby gem for Amazon Simple Storage Service (Amazon S3)
Official AWS Ruby gem for Amazon Simple Storage Service (Amazon S3).
2023-06-06T02:18:17+08:00 devel/py-jaraco.env Facilities for environment variables
This library facilitates handling of environment variables.
2023-06-06T02:18:16+08:00 devel/py-cacheyou httplib2 caching for requests
CacheYou is a fork of CacheControl which is a port of the caching algorithms in
httplib2 for use with requests session object.
2023-06-06T02:18:15+08:00 math/fast_float Fast and exact C++ number parsing library
The fast_float library provides fast header-only implementations for the C++
from_chars functions for float and double types. These functions convert ASCII
strings representing decimal values (e.g., 1.3e10) into binary types. We provide
exact rounding (including round to even). In our experience, these fast_float
functions many times faster than comparable number-parsing functions from
existing C++ standard libraries.
2023-06-04T14:51:09-05:00 devel/py-setuptools-gettext Setuptools plugin for gettext
setuptools-gettest is a plugin for setuptools to use gettext to compile
.po files into .mo files.
2023-06-05T08:18:01-07:00 devel/klib Standalone and lightweight C library
Klib is a standalone and lightweight C library distributed under MIT/X11
license. Most components are independent of external libraries, except the
standard C library, and independent of each other. To use a component of
this library, you only need to copy a couple of files to your source code
tree without worrying about library dependencies.

Klib strives for efficiency and a small memory footprint. Some components,
such as hash table, B-tree, vector and sorting algorithms, are among the most
efficient implementations of similar algorithms or data structures in all
programming languages, in terms of both speed and memory use.
2023-06-05T11:31:24+00:00 devel/libevent-devel API for executing callback functions on events or timeouts
The libevent API provides a mechanism to execute a callback function when
a specific event occurs on a file descriptor or after a timeout has been
reached. Furthermore, libevent also support callbacks due to signals or
regular timeouts.

libevent is meant to replace the event loop found in event driven network
servers. An application just needs to call event_dispatch() and then add
or remove events dynamically without having to change the event loop.

Currently, libevent supports /dev/poll, kqueue(2), event ports, select(2),
poll(2) and epoll(4). The internal event mechanism is completely independent
of the exposed event API, and a simple update of libevent can provide new
functionality without having to redesign the applications. As a result,
Libevent allows for portable application development and provides the most
scalable event notification mechanism available on an operating system.
Libevent can also be used for multi-threaded applications.
2023-06-04T15:38:16-07:00 editors/orbiton Small, fast and limited text editor in Go
Small, fast and limited text editor

Features and limitations:
* Has syntax highlighting for Go code.
* Never asks before saving or quitting. Be careful.
* Home and End are not detected by the key handler.
* Can format Go code using gofmt (press ctrl-f).
* Expects utilities like gofmt to be in /usr/bin.
* Will strip trailing whitespace whenever it can.
* Must be given a filename at start.
* Requires that /dev/tty is available.
* Copy, cut and paste is only for one line at a time.
* Some letters can not be typed in. Like the "ash" grapheme
formed from the letters a and e.
2023-06-04T14:57:17-07:00 devel/gradle761 Project automation tool
Gradle is build automation evolved.

Gradle can automate the building, testing, publishing, deployment
and more of software packages or other types of projects such as
generated static websites, generated documentation or indeed anything
else.

Gradle combines the power and flexibility of Ant with the dependency
management and conventions of Maven into a more effective way to
build. Powered by a Groovy DSL and packed with innovation, Gradle
provides a declarative way to describe all kinds of builds through
sensible defaults. Gradle is quickly becoming the build system of
choice for many open source projects, leading edge enterprises and
legacy automation challenges.
2023-06-04T13:30:20-07:00 science/py-dftbplus DFTB+: Package for performing fast atomistic simulations
DFTB+ is a fast and efficient versatile quantum mechanical simulation software
package. Using DFTB+ you can carry out quantum mechanical simulations similar to
density functional theory but in an approximate way, typically gaining around
two orders of magnitude in speed.

DFTB+ can be used either as a standalone application or embeded it into other
academic or commercial simulation packages as a library.
2023-06-03T00:22:02+00:00 textproc/quickwit Sub-second search & analytics engine on cloud storage
Quickwit is the fastest search engine on cloud storage.

o Full-text search and aggregation queries
o Sub-second search on cloud storage (Amazon S3, Azure Blob Storage, ...)
o Decoupled compute and storage, stateless indexers & searchers
o Schemaless or strict schema indexing
o Kubernetes ready - See our helm-chart
o OTEL-native for logs and traces
o Jaeger-native
o RESTful API
2023-06-03T12:35:30+01:00 net/dico Flexible modular implementation of DICT server
GNU Dico is a flexible modular implementation of DICT server (RFC 2229).
It handles database accesses using loadable modules, and does not depend
on particular database format. The package includes several loadable
modules for interfacing with various database formats, among them a
module for dict.org databases. New modules can be written in C, Guile or
Python. The package also includes a console client program for querying
remote dictionary servers.
2023-06-03T10:51:39+01:00 databases/imposm3 Imposm imports OpenStreetMap data into PostGIS
Imposm is an importer for OpenStreetMap data. It reads PBF files and
imports the data into PostgreSQL/PostGIS. It can also automatically
update the database with the latest changes from OSM.

It is designed to create databases that are optimized for rendering
(i.e. generating tiles or for WMS services).
2023-05-26T12:42:02+02:00 devel/poser C framework for POsix SERvices
This is a lightweight framework to easily implement a typical (networking)
service in C, using an event-driven API.

It only uses standard POSIX APIs, therefore it is not suitable for services
that must scale to thousands of concurrent clients.
2023-06-02T17:51:29+02:00 www/py-dj41-drf-spectacular-sidecar Serve self-contained Swagger UI/Redoc distribution builds with Django
Serve self-contained distribution builds of Swagger UI and Redoc with Django
either via runserver or collectstatic.

This Django app is an optional addition to drf-spectacular, but does not depend
on it. It may also be used independently.
2023-06-02T17:49:48+02:00 www/py-dj41-drf-spectacular Sane/flexible OpenAPI 3 schema generation for Django REST framework
This project has 3 goals:

* Extract as much schema information from DRF as possible.
* Provide flexibility to make the schema usable in the real world (not only
toy examples).
* Generate a schema that works well with the most popular client generators.

The code is a heavily modified fork of the DRF OpenAPI generator, which is/was
lacking all of the below listed features:

* Serializers modelled as components. (arbitrary nesting + recursion supported)
* @extend_schema decorator for customization of APIView, Viewsets,
function-based views, and @action
* Authentication support (DRF natives included, easily extendable)
* Custom serializer class support (easily extendable)
* SerializerMethodField() type via type hinting or @extend_schema_field
* i18n support, Tags extraction, Description extraction from docstrings
* Request/response/parameter examples, Callback operations
* Vendor specification extensions (x-*) in info, operations, parameters,
components, and security schemes
* Sane fallbacks and sane operation_id naming (based on path)
* Schema serving with SpectacularAPIView (Redoc and Swagger-UI views are
also available)
* Optional input/output serializer component split
2023-05-31T10:23:55+02:00 graphics/tippecanoe Builds vector tilesets from large (or small) collections GEO features
Tippecanoe Builds vector tilesets from large (or small) collections of
GeoJSON, FlatGeobuf, or CSV features.

The goal of Tippecanoe is to enable making a scale-independent view of
your data, so that at any level from the entire world to a single
building, you can see the density and texture of the data rather than a
simplification from dropping supposedly unimportant features or
clustering or aggregating them.

If you give it all of OpenStreetMap and zoom out, it should give you
back something that looks like "All Streets" rather than something that
looks like an Interstate road atlas.

If you give it all the building footprints in Los Angeles and zoom out
far enough that most individual buildings are no longer discernable, you
should still be able to see the extent and variety of development in
every neighborhood, not just the largest downtown buildings.

If you give it a collection of years of tweet locations, you should be
able to see the shape and relative popularity of every point of interest
and every significant travel corridor.
2023-06-01T05:49:47+09:00 net/sniffnet Comfortably monitor your Internet traffic
Sniffnet is a network monitoring tool to help you easily keep track of
your Internet traffic.

Whether you want to gather statistics, or you need to inspect more in
depth what's going on in your network, this app will get you covered.
2023-05-27T09:06:05-03:00 www/trurl Parses, manipulates and outputs URLs and parts of URLs
trurl parses, manipulates and outputs URLs and parts of URLs.

It uses the RFC 3986 definition of URLs and it uses libcurl's URL
parser to do so, which includes a few "extensions". The URL support is
limited to "hierarchical" URLs, the ones that use "://" separators
after the scheme.

Typically you pass in one or more URLs and decide what of that you want
output. Posssibly modifying the URL as well.

trurl knows URLs and every URL consists of up to ten separate and
independent "components". These components can be extracted, removed
and updated with trurl and they are referred to by their respective
names: scheme, user, password, options, host, port, path, query,
fragment and zoneid.
2023-05-30T01:33:33-07:00 misc/py-pytorch-lightning Lightweight PyTorch wrapper for ML researchers
The Deep Learning framework to train, deploy, and ship AI products
lightning fast.
2023-05-30T01:05:14-07:00 misc/py-torchmetrics PyTorch native metrics
TorchMetrics is a collection of 90+ PyTorch metrics implementations and an
easy-to-use API to create custom metrics. It offers:
* A standardized interface to increase reproducibility
* Reduces Boilerplate
* Distributed-training compatible
* Rigorously tested
* Automatic accumulation over batches
* Automatic synchronization between multiple devices
2023-05-30T00:45:28-07:00 misc/py-lightning-utilities PyTorch Lightning sample project
Common Python utilities and GitHub Actions in Lightning Ecosystem.
2023-05-29T14:22:29+00:00 x11/wayidle Wait for wayland compositor idle timeouts
Wayidle waits until the Wayland compositor reports being N seconds
idle. If a command was specified, it will "exec" into that command,
otherwise, it will exit zero.

Wayidle is designed for usage is shell scripts or execline scripts.
2023-05-29T16:46:09-07:00 misc/py-torch-geometric Graph neural network library for PyTorch
PyG (PyTorch Geometric) is a library built upon PyTorch to easily write and
train Graph Neural Networks (GNNs) for a wide range of applications related
to structured data.

It consists of various methods for deep learning on graphs and other irregular
structures, also known as geometric deep learning, from a variety of published
papers. In addition, it consists of easy-to-use mini-batch loaders for
operating on many small and single giant graphs, multi GPU-support,
torch.compile support, DataPipe support, a large number of common benchmark
datasets (based on simple interfaces to create your own), the GraphGym
experiment manager, and helpful transforms, both for learning on arbitrary
graphs as well as on 3D meshes or point clouds.
2023-02-09T19:31:43+01:00 lang/mlkit Standard ML compiler
The MLKit is a compiler toolkit for the Standard ML language, including
The MLKit with Regions, which features a native backend for
the x64 architecture, based on region inference, and SMLtoJs,
which features a JavaScript backend targeting web browsers.
The two compilers share the same frontend and compilation management scheme.

The MLKit covers all of Standard ML, as defined in the 1997 edition of
The Definition of Standard ML and supports most of
the Standard ML Basis Library.
2023-05-29T20:52:38+02:00 security/git-credential-oauth Git credential helper for GitHub and other forges using OAuth
git-credential-oauth is a Git credential helper that securely
authenticates to GitHub, GitLab, BitBucket and Gerrit using OAuth.

The first time you push, the helper will open a browser window to
authenticate. Subsequent pushes within storage lifetime require no
interaction.
2023-05-28T09:59:28-07:00 devel/py-ewah-bool-utils EWAH Bool Array utils for yt
EWAH Bool Array utils for yt.
2023-05-28T07:18:46+08:00 textproc/rubygem-elasticsearch-api7 Ruby API for Elasticsearch
Ruby API for Elasticsearch. See textproc/rubygem-elasticsearch for more
details.
2023-05-28T07:18:43+08:00 textproc/rubygem-elasticsearch7 Ruby integrations for Elasticsearch
Ruby integrations for Elasticsearch that feature:

* a client for connecting to an Elasticsearch cluster
* a Ruby API for the Elasticsearch's REST API
* various extensions and utilities
2023-05-28T07:18:40+08:00 textproc/rubygem-elastic-transport Low level Ruby client for Elastic
Elastic Transport provides a low-level Ruby client for connecting to an Elastic
cluster. It powers both the Elasticsearch client and the Elastic Enterprise
Search client.
2023-05-28T07:18:37+08:00 sysutils/rubygem-ohai17 Ohai profiles your system and emits JSON
Ohai detects data about your operating system. It can be used standalone, but
it's primary purpose is to provide node data to Chef.

Ohai will print out a JSON data blob for all the known data about your system.
When used with Chef, that data is reported back via node attributes.
2023-05-28T07:18:34+08:00 sysutils/rubygem-chef17 Systems integration framework. Client part
Chef is a systems integration framework, built to bring the benefits of
configuration management to your entire infrastructure. With Chef, you can:

* Manage your servers by writing code, not by running commands.
* Integrate tightly with your applications, databases, LDAP directories, and
more.
* Easily configure applications that require knowledge about your entire
infrastructure ("What systems are running my application?" "What is the
current master database server?")
2023-05-28T07:18:31+08:00 net/rubygem-train-rest Provide a transport to communicate easily with RESTful APIs
Train transport provides a transport to communicate easily with RESTful APIs.
2023-05-28T07:18:27+08:00 net/rubygem-proxifier2 Add HTTP or SOCKS proxies support and force TCPSocket to use proxies
This gem was created for 2 purposes.

First is to enable ruby programmers to use HTTP or SOCKS proxies interchangeably
when using TCPSockets. Either manually with Proxifier::Proxy#open or by require
"proxifier/env".

The second purpose is to use ruby code that doesn't use proxies for users that
have to use proxies. The pruby and pirb executables are simple wrappers for
their respective ruby executables that support proxies from environment
variables.
2023-05-28T07:18:23+08:00 net/rubygem-octokit5 Simple wrapper for the GitHub API
Octokit.rb wraps the GitHub API in a flat API client that follows Ruby
conventions and requires little knowledge of REST.
2023-05-28T07:18:18+08:00 devel/rubygem-aws-sdk-mediapackagev2 Official AWS Ruby gem for AWS Elemental MediaPackage v2 (mediapackagev2)
Official AWS Ruby gem for AWS Elemental MediaPackage v2 (mediapackagev2).
2023-05-28T07:18:17+08:00 devel/rubygem-aws-sdk-core3172 AWS SDK for Ruby - Core
Provides API clients for AWS. This gem is part of the official AWS SDK for
Ruby.
2023-05-28T07:18:16+08:00 devel/py-py3nvml Python 3 Bindings for the NVIDIA Management Library
Python 3 compatible bindings to the NVIDIA Management Library. Can be used to
query the state of the GPUs on your system. This was ported from the NVIDIA
provided python bindings nvidia-ml-py, which only supported python 2.
2023-05-28T07:18:16+08:00 devel/py-overrides Decorator to automatically detect mismatch when overriding a method
A decorator @override that verifies that a method that should override an
inherited method actually does it.

Copies the docstring of the inherited method to the overridden method.

Since signature validation and docstring inheritance are performed on class
creation and not on class instantiation, this library significantly improves the
safety and experience of creating class hierarchies in Python without
significantly impacting performance. See https://stackoverflow.com/q/1167617 for
the initial inspiration for this library.
2023-05-28T07:18:15+08:00 devel/py-opentelemetry-semantic-conventions OpenTelemetry Semantic Conventions
This library contains generated code for the semantic conventions defined by the
OpenTelemetry specification.
2023-05-28T07:18:14+08:00 devel/py-opentelemetry-sdk OpenTelemetry Python SDK
This library provides Python SDK for OpenTelemetry project.
2023-05-28T07:18:13+08:00 textproc/p5-HTML-T5 HTML validation in a Perl object
HTML::T5 is an HTML checker in a handy dandy object. It's meant as a replacement
for HTML::Lint.
2023-03-09T21:47:25+03:00 lang/ghc92
2023-05-27T06:46:37+02:00 security/transcrypt Transparently encrypt files within a git repository
A script to configure transparent encryption of sensitive files stored in a Git
repository. Files that you choose will be automatically encrypted when you
commit them, and automatically decrypted when you check them out. The process
will degrade gracefully, so even people without your encryption password can
safely commit changes to the repository's non-encrypted files.

Transcrypt protects your data when it's pushed to remotes that you may not
directly control (e.g., GitHub, Dropbox clones, etc.), while still allowing you
to work normally on your local working copy. You can conveniently store things
like passwords and private keys within your repository and not have to share
them with your entire team or complicate your workflow.
2023-05-26T13:49:25+02:00 databases/immudb Database with built-in cryptographic proof and verification
Open source immutable database

* High performance and easy to integrate
* Supports both Key/Value & SQL
* Cryptographical client-verification, tamper-resistant, and auditable
* Versioned and temporal queries subject to cryptographic verification
2023-05-27T12:06:47+08:00 textproc/rubygem-loofah220 Library for manipulating HTML/XML documents and fragments
Loofah is a general library for manipulating HTML/XML documents and fragments.
It's built on top of Nokogiri and libxml2, so it's fast and has a nice API.
Loofah excels at HTML sanitization (XSS prevention). It includes some nice HTML
sanitizers, which are based on HTML5lib's whitelist.
2023-05-27T12:06:44+08:00 devel/rubygem-oj313 Fast JSON parser and serializer
The fastest JSON parser and object serializer.
2023-05-27T12:06:43+08:00 devel/rubygem-google-protobuf322 Ruby extension to Google Protocol Buffers
rubygem-google-protobuf is a Ruby extension that implements Protocol Buffers
functionality. It makes use of generated Ruby code that defines message and enum
types in a Ruby DSL. You may write definitions in this DSL directly, but we
recommend using protoc's Ruby generation support with .proto files. The build
process in this directory only installs the extension; you need to install
protoc as well to have Ruby code generation functionality.
2023-05-27T12:06:43+08:00 devel/rubygem-aws-sdk-core3171 AWS SDK for Ruby - Core
Provides API clients for AWS. This gem is part of the official AWS SDK for
Ruby.
2023-05-27T12:06:42+08:00 net/py-trio-websocket WebSocket library for Trio
Trio WebSocket implements both server and client aspects of the the WebSocket
protocol, striving for safety, correctness, and ergonomics. It is based on the
wsproto project, which is a Sans-IO state machine that implements the majority
of the WebSocket protocol, including framing, codecs, and events. This library
handles I/O using the Trio framework. This library passes the Autobahn Test
Suite.
2023-05-27T12:06:37+08:00 devel/py-pytest-jupyter pytest plugin for testing Jupyter libraries and extensions
pytest-jupyter provides a set of pytest plugins for Jupyter libraries and
extensions.
2023-05-27T12:06:37+08:00 devel/py-hatch-autorun Hatch build hook plugin to inject code that will automatically run
hatch-autorun provides a build hook plugin for Hatch that injects code into an
installation that will automatically run before the first import.
2023-05-27T12:06:36+08:00 devel/py-crontab Parse and use crontab schedules in Python
This package intends to offer a method of parsing crontab schedule entries and
determining when an item should next be run. More specifically, it calculates a
delay in seconds from when the .next() method is called to when the item should
next be executed.
2023-05-27T12:06:35+08:00 sysutils/ncdu2 NCurses Disk Usage (stable version written in Zig)
Ncdu is a disk usage analyzer with an ncurses interface. It is designed to find
space hogs on a remote server where you don't have an entire graphical setup
available, but it is a useful tool even on regular desktop systems. Ncdu aims to
be fast, simple and easy to use, and should be able to run in any minimal
POSIX-like environment with ncurses installed.
2023-05-26T18:00:01+02:00 net/speedtest-go CLI and Go API to test internet speed using speedtest.net
Command line interface and pure Go API to test internet speed using
speedtest.net. Able to speedtest 2x faster than speedtest.net with
almost the same result.
2023-05-26T09:09:32+00:00 net-p2p/ed2k-hash Calculate eD2K hashes and create ed2k:// file links
This tool takes a file and calculates the final 'eDonkey/Overnet
hash' for it that you need if you want to create ed2k:// links to
that file.

It also spits out the complete ed2k:// link in the end and appends
it to the file 'ed2k_links.txt' for easier copy-and-paste later on.
2023-05-26T08:55:12+00:00 misc/lsix List files with thumbnails using Sixel graphics
This program is like ls(1), but for images: it shows thumbnails in
terminal using DEC SIXEL graphics. It uses ImageMagick, so pretty
much any image format will be supported.
2023-05-26T10:46:05+02:00 graphics/3d-ascii-viewer-c Viewer of 3D models in ASCII
3d-ascii-viewer-c is a program written in C that allows users to view 3D
models in ASCII. It supports Wavefront .obj files and provides an
example usage capture.

The program can be executed by passing any of the models in the models
folder as an argument.

The available models include Fox and ShibaInu models, as well as Tree
models.

This program is inspired by the ASCII luminescence and offers an
intuitive way of viewing 3D models in ASCII.
2023-05-26T10:08:16+02:00 textproc/crow-translate Translator using Google, Yandex Bing, LibreTranslate and Lingva
A simple and lightweight translator that allows you to translate and
speak text using Google, Yandex Bing, LibreTranslate and Lingva.
2023-05-25T20:50:15-04:00 devel/bazel5 Fast and correct build system
Bazel is Google's own build tool, now publicly available in Beta.
Bazel has built-in support for building both client and server
software, including client applications for both Android and iOS
platforms. It also provides an extensible framework that you can
use to develop your own build rules.
2023-03-26T16:55:28-05:00 textproc/py-merge3 3-way merge implementation
A Python implementation of 3-way merge of texts.

Given BASE, OTHER, THIS, tries to produce a combined text incorporating
the changes from both BASE->OTHER and BASE->THIS. All three will
typically be sequences of lines.
2023-05-19T21:48:26+03:00 x11-fonts/cozette Bitmap programming font optimized for coziness
Cozette is a 6x13px (bounding box; average 5px character width, 3px descent,
10px ascent, 8px cap height) bitmap font with great coverage of all the
ghyphs.
2023-05-21T23:10:40+02:00 net/gost Simple security tunnel written in Golang
A simple security tunnel written in Golang.

It can listen on multiple ports, chain proxies, supports
wide variety of protocols (HTTP, HTTP2, HTTPS, SOCKS).
2023-05-23T10:27:58+01:00 x11-fonts/intel-one-mono Intel One Mono font
Intel One Mono is an expressive monospaced font family that's built with
clarity, legibility, and the needs of developers in mind.

Identifying the typographically underserved low-vision developer audience,
Frere-Jones Type designed the Intel One Mono typeface in partnership with the
Intel Brand Team and VMLY&R, for maximum legibility to address developers'
fatigue and eyestrain and reduce coding errors. A panel of low-vision and
legally blind developers provided feedback at each stage of design.
2023-05-22T22:47:44+09:00 mail/cyrus-imapd38 Cyrus mail server, supporting POP3 and IMAP4 protocols ${COMMENT_${FLAVOR}}
The Cyrus IMAP (Internet Message Access Protocol) server provides access to
personal mail and system-wide bulletin boards through the IMAP protocol.
The Cyrus IMAP server is a scaleable enterprise mail system designed for use
from small to large enterprise environments using standards-based
technologies.

A full Cyrus IMAP implementation allows a seamless mail and bulletin board
environment to be set up across multiple servers. It differs from other
IMAP server implementations in that it is run on "sealed" servers, where
users are not normally permitted to log in. The mailbox database is stored
in parts of the filesystem that are private to the Cyrus IMAP system. All
user access to mail is through software using the IMAP, POP3, or KPOP
protocols.

The private mailbox database design gives the server large advantages in
efficiency, scalability, and administratability. Multiple concurrent
read/write connections to the same mailbox are permitted. The server
supports access control lists on mailboxes and storage quotas on mailbox
hierarchies.
2023-05-20T22:24:34-07:00 math/py-ambit Library for tensor product calculations
Python bindings for the C++ library implementing the tensor product calculations
through a clean, concise user interface.
2023-05-20T12:17:31-03:00 devel/py-azure-mgmt-appcontainers Microsoft Azure Appcontainers Management Client Library for Python
This is the Microsoft Azure Appcontainers Management Client Library.

Azure Resource Manager (ARM) is the next generation of management APIs that
replace the old Azure Service Management (ASM).
2023-05-20T09:25:54+02:00 ports-mgmt/submodules2tuple GH_TUPLE generator for GitHub projects with submodules
FreeBSD ports developers often encounter projects hosted on GitHub that
make use of submodules. Manually creating the GH_TUPLE values for such
projects can be time-consuming and error-prone, especially when dealing
with recursive submodules. This script simplifies the process by
automating the generation of these values, saving developers valuable
time and effort.
2023-05-19T13:43:35+02:00 x11-fonts/tt2020 Advanced, hyperrealistic, multilingual typewriter font
TT2020 is an advanced, open source, hyperrealistic, multilingual
typewriter font for a new decade.
2023-05-19T10:00:33+00:00 lang/erlang-runtime26 Functional programming language from Ericsson
Erlang is a programming language used to build massively scalable soft
real-time systems with requirements on high availability. Some of its
uses are in telecoms, banking, e-commerce, computer telephony and
instant messaging. Erlang's runtime system has built-in support for
concurrency, distribution and fault tolerance.

This port contains a standalone runtime environment of Erlang 26
to be used during the development of OTP applications.
2023-05-19T11:59:06+02:00 x11-fonts/chomsky New York Times masthead, reimagined as a full font
This is Chomsky, a newspaper masthead font in the style of the New York
Times masthead.
2023-04-29T07:42:50+02:00 databases/qt6-base_sqldriver Qt base (${FLAVOR} sqldriver)
Qt Base
2023-05-14T10:26:17+02:00 sysutils/plocate Fast & privacy-respecting locate utility
plocate is a locate(1) based on posting lists, completely replacing mlocate
with a much faster (and smaller) index. It is suitable as a default locate on
your system. Like mlocate and slocate, the returned file set is
user-dependent, ie. a user will only see a file if find(1) would list it (all
directories from the root have +rx permissions).
2023-05-15T18:23:36+02:00 graphics/sdl2_gpu Hardware-accelerated 2D graphics library
SDL_gpu, a library for making hardware-accelerated 2D graphics easy.

- High performance (it automatically collects and submits batches
instead of separate draw commands for each sprite and redundant
state changes)
- Shader API
- Arbitrary geometry rendering (triangles)
- Can be integrated with explicit OpenGL calls (mixed 2D and 3D)
- Full blend state control
- Built-in primitive shapes (points, lines, tris, rects, ellipses,
polygons, even arcs)
- Uses a style familiar to SDL 1.2 users
- Compatible with either SDL 1.2 or 2.0
- Loads BMP, TGA, and PNG files via stb-image
- Rotates and scales about the center of images, making reasoning
about the resulting corner coordinates more obvious (adjustable
via anchor settings)
2023-05-15T09:08:11+01:00 www/adjuster Apply custom processing to Web pages
Web Adjuster, Annotator Generator and TermLayout

These are tools for applying custom processing to Web pages,
particularly useful for mobile browsers that do not support
browser extensions.

* Web Adjuster is a domain-rewriting proxy that can inject
Javascript and/or CSS into every page, as well as running
the text through an arbitrary filter command;

* Annotator Generator is an examples-driven generator of fast
text annotators (that add language-learning hints to text):
these can be used as filters in Web Adjuster;

* TermLayout displays complex Web layouts on text terminals.
2023-05-18T06:08:16+00:00 net-p2p/py-ed2k-tools Python framework for manipulating eD2K metafiles
This is a Python framework for easy manipulation of .part.met files
(Overnet/eDonkey2000 download meta-information). This set of classes
allows for rapid development of ed2k tools, using a very simple API.
2023-05-18T08:56:46+03:00 www/rubygem-rack227 Rack, a Ruby Webserver Interface
Rack provides a minimal, modular and adaptable interface for developing web
applications in Ruby. By wrapping HTTP requests and responses in the simplest
way possible, it unifies and distills the API for web servers, web frameworks,
and software in between (the so-called middleware) into a single method call.
2023-05-18T08:56:46+03:00 www/rubygem-circuitbox A robust circuit breaker that manages failing external services
Circuitbox is a Ruby circuit breaker gem. It protects your application from
failures of its service dependencies. It wraps calls to external services and
monitors for failures in one minute intervals. Using a circuit's defaults once
more than 5 requests have been made with a 50% failure rate, Circuitbox stops
sending requests to that failing service for 90 seconds. This helps your
application gracefully degrade.
2023-05-18T08:56:46+03:00 textproc/rubygem-loofah221 Library for manipulating HTML/XML documents and fragments
Loofah is a general library for manipulating HTML/XML documents and fragments.
It's built on top of Nokogiri and libxml2, so it's fast and has a nice API.
Loofah excels at HTML sanitization (XSS prevention). It includes some nice HTML
sanitizers, which are based on HTML5lib's whitelist.
2023-05-18T08:56:46+03:00 net/rubygem-devfile Library used to generate kubernetes manifests from a Devfile
This gem generates Kubernetes yamls from a Devfile. This gem wraps the existing
go Devfile library using FFI.
2023-05-18T08:56:46+03:00 lang/rubygem-rb_sys Helpers for compiling Rust extensions for ruby
The goal of this project is to provide a language server implementation for ruby
in ruby.
2023-05-18T08:56:46+03:00 databases/rubygem-neighbor Ruby nearest neighbor search for Rails and Postgres
Nearest neighbor search for Rails and Postgres
2023-05-17T02:28:12+00:00 x11/libei Library for Emulated Input
libei is a library for Emulated Input, primarily aimed at the Wayland
stack. It provides three parts:
- EI (Emulated Input) for the client side (libei)
- EIS (Emulated Input Server) for the server side (libeis)
- oeffis is an optional helper library for DBus communication with the
XDG RemoteDesktop portal (liboeffis)
2023-03-19T19:46:04+00:00 devel/py-strenum Enum that inherits from str
StrEnum is a Python enum.Enum that inherits from str to complement
enum.IntEnum in the standard library.
2023-05-17T12:43:42+02:00 devel/kommit Git gui client for KDE
A git gui for KDE.
2023-05-16T10:25:27-05:00 sysutils/appjail-devel Simple and easy-to-use tool for creating portable jails (devel)
AppJail is an open source framework entirely written in sh(1) and
C to create isolated, portable and easy to deploy environments using
FreeBSD jails that behaves like an application.
2023-05-16T14:02:45+03:00 net/rubygem-octokit4 Simple wrapper for the GitHub API
Octokit.rb wraps the GitHub API in a flat API client that follows Ruby
conventions and requires little knowledge of REST.
2023-05-16T07:30:43+03:00 www/rubygem-ruby-openai37 OpenAI API + Ruby
OpenAI API + Ruby
2023-05-12T21:19:23+09:00 lang/ruby33 Object-oriented interpreted scripting language
Ruby is the interpreted scripting language for quick and
easy object-oriented programming. It has many features to
process text files and to do system management tasks (as in
Perl). It is simple, straight-forward, and extensible.

Features of Ruby are shown below.

+ Simple Syntax
+ *Normal* Object-Oriented features(ex. class, method calls)
+ *Advanced* Object-Oriented features(ex. Mix-in, Singleton-method)
+ Operator Overloading
+ Exception Handling
+ Iterators and Closures
+ Garbage Collection
+ Dynamic Loading of Object files(on some architecture)
+ Highly Portable(works on many UNIX machines, and on DOS,
Windows, Mac, BeOS etc.)
2023-04-20T10:05:03+03:00 textproc/rubygem-semver_dialects Parse, process and compare semantic versions
This gem helps to parse, process and compare semantic versions
for Maven, NPM, PHP, RubyGems and python packages.
2023-04-20T10:05:03+03:00 sysutils/rubygem-ohai16 Ohai profiles your system and emits JSON
Ohai detects data about your operating system. It can be used standalone, but
it's primary purpose is to provide node data to Chef.

Ohai will print out a JSON data blob for all the known data about your system.
When used with Chef, that data is reported back via node attributes.
2023-04-20T10:05:03+03:00 sysutils/rubygem-chef16 Systems integration framework. Client part
Chef is a systems integration framework, built to bring the benefits of
configuration management to your entire infrastructure. With Chef, you can:

* Manage your servers by writing code, not by running commands.
* Integrate tightly with your applications, databases, LDAP directories, and
more.
* Easily configure applications that require knowledge about your entire
infrastructure ("What systems are running my application?" "What is the
current master database server?")
2023-04-20T10:05:03+03:00 sysutils/rubygem-chef-utils17 Basic utility functions for Core Chef Infra development
Chef Utils gem contains common code and mixins for the core Chef Infra Ruby
gems. This is intended to be a "core" or "foundations" library for the chef
ecosystem (and external related gems) which allows the use of core code and
utility functions of the chef gem without requiring all the heaviness of the
chef gem.
2023-04-20T10:05:03+03:00 sysutils/rubygem-chef-config17 Default configuration and config loading library for Chef
ChefConfig is the default configuration and config loading library for Chef.
2023-04-20T10:05:03+03:00 sysutils/rubygem-chef-bin17 Chef-branded binstubs for chef-client
chef-bin provides the binstubs for chef-client.
2023-04-20T10:05:03+03:00 devel/rubygem-ruby-openai OpenAI API + Ruby
OpenAI API + Ruby
2023-04-20T10:05:03+03:00 devel/rubygem-google-apis-androidpublisher_v3034 Simple REST client for Google Play Android API V3
This is the simple REST client for Google Play Android Developer API V3.
Simple REST clients are Ruby client libraries that provide access to Google
services via their HTTP REST API endpoints. These libraries are generated
and updated automatically based on the discovery documents published by the
service, and they handle most concerns such as authentication, pagination,
retry, timeouts, and logging. You can use this client to access the Google
Play Android Developer API, but note that some services may provide a
separate modern client that is easier to use.
2023-04-20T10:05:03+03:00 devel/rubygem-corefoundation Wrapper for macOS Core Foundation Framework
Ruby wrapper for macOS Core Foundation framework
2023-04-20T10:05:03+03:00 devel/rubygem-aws-sdk-s31121 Official AWS Ruby gem for Amazon Simple Storage Service (Amazon S3)
Official AWS Ruby gem for Amazon Simple Storage Service (Amazon S3).
2023-05-13T17:32:21+02:00 audio/py-pyttsx3 Offline Text To Speech (TTS) converter for Python
pyttsx3 is a text-to-speech conversion library in Python.
Unlike alternative libraries, it works offline.
2023-05-12T19:02:17+09:00 databases/closql-devel Store EIEIO objects using EmacSQL
Store uniform EIEIO objects in an EmacSQL database. SQLite is used as
backend. This library imposes some restrictions on what kind of
objects can be stored; it isn't intended to store arbitrary
objects. All objects have to share a common superclass and subclasses
cannot add any additional instance slots.
2023-05-12T18:44:36+09:00 databases/emacsql-devel High-level Emacs Lisp RDBMS front-end (Development Version)
EmacSQL is a high-level Emacs Lisp front-end for SQLite (primarily),
PostgreSQL, MySQL, and potentially other SQL databases.

It works by maintaining a inferior process running (a "connection")
for interacting with the back-end database. Connections are
automatically cleaned up if they are garbage collected. All requests
are synchronous.

Any readable lisp value can be stored as a value in EmacSQL, including
numbers, strings, symbols, lists, vectors, and closures. EmacSQL has
no concept of "TEXT" values; it's all just lisp objects. The lisp
object nil corresponds 1:1 with NULL in the database.
2023-05-12T16:37:02+09:00 databases/emacs-sqlite3-api SQLite3 API for Emacs 25+
emacs-sqlite3-api is a dynamic module for GNU Emacs 25+ that provides
direct access to the core SQLite3 C API from Emacs Lisp.
2023-05-12T15:44:08+02:00 games/bucklespring Nostalgia bucklespring keyboard sound
Bucklespring runs as a background process and plays back the sound of
each key pressed and released on your keyboard, just as if you were
using an IBM Model-M. The sound of each key has carefully been sampled,
and is played back while simulating the proper distance and direction
for a realistic 3D sound palette of pure nostalgic bliss.
2023-05-12T07:31:40-05:00 devel/py-rich-click Format click help output nicely with rich
The intention of rich-click is to provide attractive help output from
click, formatted with rich, with minimal customisation required.
2023-05-08T20:54:50+00:00 net/wifi-firmware-kmod Firmware modules for WiFi NIC drivers
Meta port for the firmware modules for the WiFi NIC drivers.
2023-05-01T08:46:28-04:00 graphics/py-colorz Color scheme generator
A color scheme generator. Takes an image (local or online) and grabs
the most dominant colors using kmeans. Also creates bold colors by
adding value to the dominant colors. Finally, outputs the colors
to stdout (one normal and one bold per line, space delimited) and
generates an HTML preview of the color scheme.
2023-04-28T07:09:46-04:00 textproc/py-reindent Reindent python scripts
Change Python (.py) files to use 4-space indents and no hard tab characters.
Also trim excess spaces and tabs from ends of lines, and remove empty lines
at the end of files. Also ensure the last line ends with a newline.
2023-05-11T07:54:49+00:00 print/ipp-usb Daemon for IPP over USB printer support
ipp-usb daemon enables driver-less printing and scanning on USB-only
AirPrint-compatible printers and MFPs. It works by connecting to the device by
USB using IPP-over-USB protocol, and exposing the device to the network,
including DNS-SD (ZeroConf) advertising. IPP printing, eSCL scanning and web
console are fully supported.
2023-05-09T21:47:54+02:00 emulators/tic-80 Fantasy game console
TIC-80 is a free and open source fantasy computer for making, playing
and sharing tiny games.

With TIC-80 you get built-in tools for development: code, sprites, maps,
sound editors and the command line, which is enough to create a mini
retro game.

Games are packaged into a cartridge file, which can be easily
distributed. TIC-80 works on all popular platforms. This means your
cartridge can be played in any device.

To make a retro styled game, the whole process of creation and execution
takes place under some technical limitations: 240x136 pixel display,
16 color palette, 256 8x8 color sprites, 4 channel sound, etc.
2023-05-11T05:37:30+02:00 security/py-netbox-secrets Secret store for NetBox
This is the continuation of the NetBox Secretstore app. The original plugin is
minimally maintained and has a lot of issues.

This plugin is a complete rewrite of the original plugin. It is more generic
and flexible than the original plugin. It is also regularly tested with the
latest NetBox releases to ensure compatibility and stability.

Features:

* Store secrets in the database encrypted with a public key (RSA)
* More generic and flexible than the original plugin (e.g. secrets
can be assigned to any object in NetBox)
* Secrets can be assigned to contacts to associate them with
a secret (e.g. SSH key)
* Updated user interface to make it easier to use and more intuitive
to navigate
* Regularly tested with the latest NetBox releases to ensure
compatibility and stability
2023-05-10T14:57:16+00:00 devel/py-celery-singleton Prevent duplicate celery tasks
celery-singleton uses the JSON representation of a task's delay() or
apply_async() arguments to generate a unique lock and stores it in redis. By
default it uses the redis server of the celery result backend. If you use a
different/no result backend or want to use a different redis server for
celery-singleton, refer the configuration section for how to customize the
redis.

import time
from celery_singleton import Singleton
from somewhere import celery_app

@celery_app.task(base=Singleton)
def do_stuff(*args, **kwargs):
time.sleep(4)
return 'I just woke up'

# run the task as normal
async_result = do_stuff.delay(1, 2, 3, a='b')
async_result2 = do_stuff.delay(1, 2, 3, a='b')

# These are the same, task is only queued once
assert async_result == async_result2
2023-05-09T21:20:04-07:00 math/py-dgl Deep Graph Library
DGL is a Python package built to ease deep learning on graphs
on top of existing DL frameworks.
2023-05-09T21:18:14-07:00 math/dgl Deep Graph Library
DGL is a Python package built to ease deep learning on graphs
on top of existing DL frameworks.
2023-05-08T22:45:33+00:00 devel/R-cran-clock Date-Time Types and Tools
Provides a comprehensive library for date-time manipulations using
a new family of orthogonal date-time classes (durations, time points,
zoned-times, and calendars) that partition responsibilities so that
the complexities of time zones are only considered when they are
really needed. Capabilities include: date-time parsing, formatting,
arithmetic, extraction and updating of components, and rounding.
2023-05-09T19:54:39+00:00 www/py-xyzservices Source of XYZ tiles providers
xyzservices is a lightweight library providing a repository of available XYZ
services offering raster basemap tiles. The repository is provided via Python
API and as a compressed JSON file.

XYZ tiles can be used as background for your maps to provide necessary spatial
context. xyzservices offer specifications of many tile services and provide an
easy-to-use tools to plug them into your work, no matter if interactive or
static.
2023-05-09T11:20:53+01:00 devel/py-types-jsonschema Typing stubs for jsonschema
This is a PEP 561 type stub package for the jsonschema package. It can
be used by type-checking tools like mypy, pyright, pytype, PyCharm,
etc. to check code that uses jsonschema.
2023-05-08T18:01:05+02:00 www/icapeg ICAP server implementation with Multi vendor support
ICAPeg is an Open Source implementation of ICAP (RFC 3507) server,
designed to enable web proxies to utilize the function of API based
services along with standalone executables and databases in order to
provide content inspection and manipulation services.
2023-05-09T14:36:26+08:00 databases/postgresql-pgaudit PostgreSQL Audit Extension
PostgreSQL Audit Extension (pgAudit) provides detailed session and/or
object audit logging via the standard PostgreSQL logging facility.
2023-05-08T01:41:29+02:00 news/py-sabctools Python yEnc package optimized for use within SABnzbd
Modified the original yenc module by Alessandro Duca alessandro.duca@gmail.com
for use within SABnzbd.

The module was extended to do header parsing and full yEnc decoding from a
Python list of chunks, the way in which data is retrieved from usenet. This is
particularly beneficial when SSL is enabled, which limits the size of each
chunk to 16K. Parsing these chunks in Python is much more costly. Additionally,
this module releases Python's GIL during decoding, greatly increasing
performance of the overall download process.
2023-05-07T21:15:56-07:00 misc/py-torchvision PyTorch: Datasets, transforms and models specific to computer vision
The torchvision package consists of popular datasets, model architectures, and
common image transformations for computer vision.
2023-05-07T21:03:49-07:00 misc/py-pytorch PyTorch: Tensors and dynamic neural networks in Python
PyTorch is a Python package that provides two high-level features:
* Tensor computation (like NumPy) with strong GPU acceleration
* Deep neural networks built on a tape-based autograd system
2023-05-08T07:20:03+08:00 devel/rubygem-rubocop-factory_bot Plugin for the RuboCop code style enforcing & linting tool
RuboCop factory_bot is a factory_bot-specific analysis for your projects, as an
extension to RuboCop.
2023-05-07T22:53:55+02:00 math/py-lrcalc Python bindings for lrcal
This package provides Python bindings for the Littlewood-Richardson Calculator
library (see the port math/lrcalc).

See also: https://bitbucket.org/asbuch/lrcalc/src/master/python/
2023-05-07T20:22:14+02:00 textproc/py-jupyter_sphinx Sphinx extension for rendering of Jupyter interactive widgets
jupyter-sphinx enables running code embedded in Sphinx documentation and
embedding output of that code into the resulting document. It has support for
rich output such as images and even Jupyter interactive widgets.

See also: https://github.com/jupyter/jupyter-sphinx/
2023-05-08T00:03:07+08:00 devel/py-pydantic-core Core functionality for pydantic
Pydantic-core provides the core functionality for pydantic validation and
serialization.

Pydantic-core is currently around 17x faster than pydantic v1. See
tests/benchmarks/ for details.
2023-05-07T01:10:52+09:00 lang/scratch Scratch programing language
A new programming language that makes it easy to create your own
interactive stories, animations, games, music, and art - and share your
creations on the web. Designed to help young people (ages 8 and up)
develop 21st century learning skills. As they create Scratch projects,
young people learn important mathematical and computational ideas, while
also gaining a deeper understanding of the process of design.
2023-05-01T08:18:02-04:00 x11/habak Background changing app
habak is a background changing app.

habak uses layered model. Lowermost layer is just black screen. You
can put other objects on it and these objects are called habaks.
There are three kinds of habaks: graphic files (images), texts and
"internal objects". Final background image consists of one or more
habaks positioned on the black screen. The order of habaks in the
command line is also the order of displaying them on screen. So
last habak would be drawn on the top of previous.
2023-05-01T08:39:09-04:00 graphics/py-colorthief Module for grabbing the color palette from an image
colorthief is a minimalistic python module that can be used without
adding overhead or many dependencies to your script for grabbing
the dominant color or a representative color palette of an image
using Pillow.
2023-04-29T10:06:46-04:00 graphics/py-haishoku Tool for grabbing the representative color palette from an image
Haishoku is a development tool for grabbing the dominant color or
representative color palette from an image, it depends on Python3
and Pillow.
2023-05-06T02:28:17+00:00 devel/R-cran-timechange Efficient Manipulation of Date-Times
Efficient routines for manipulation of date-time objects while
accounting for time-zones and daylight saving times. The package
includes utilities for updating of date-time components (year,
month, day etc.), modification of time-zones, rounding of date-times,
period addition and subtraction etc. Parts of the 'CCTZ' source
code, released under the Apache 2.0 License, are included in this
package. See <https: //github.com/google/cctz> for more details.
2023-05-04T14:21:30-05:00 math/octave-forge-octave-pool Octave-forge package ${OCTAVE_PKGNAME}
The octave-forge package is the result of The GNU Octave Repositry project,
which is intended to be a central location for custom scripts, functions and
extensions for GNU Octave. contains the source for all the functions plus
build and install scripts.

This is octave-pool.

Parallel computing with independent job submission for Octave.
2023-05-04T20:33:41+02:00 emulators/qemu7 QEMU CPU Emulator ${${FLAVOR}_COMMENT} - 7.X.X
QEMU is a FAST! processor emulator using dynamic translation to achieve
good emulation speed.
QEMU has two operating modes:

* Full system emulation. In this mode, QEMU emulates a full system
(for example a PC), including a processor and various peripherials.
It can be used to launch different Operating Systems without rebooting
the PC or to debug system code.
* User mode emulation (Linux host only). In this mode, QEMU can launch
Linux processes compiled for one CPU on another CPU. It can be used to
launch the Wine Windows API emulator or to ease cross-compilation and
cross-debugging.

As QEMU requires no host kernel patches to run, it is very safe and easy to use.
2023-05-04T09:24:22-07:00 math/py-fsph Library to quickly compute series of complex spherical harmonics
fsph is a library to efficiently compute series of spherical harmonics.

It is based on math enumerated by Martin J. Mohlenkamp.
2023-05-04T00:28:54-07:00 science/py-signac Manage large and heterogeneous data spaces on the file system
The signac framework helps users manage and scale file-based workflows,
facilitating data reuse, sharing, and reproducibility.

It provides a simple and robust data model to create a well-defined indexable
storage layout for data and metadata. This makes it easier to operate on large
data spaces, streamlines post-processing and analysis and makes data
collectively accessible.
2023-05-04T13:36:02+02:00 www/py-drf-spectacular-sidecar Serve self-contained Swagger UI/Redoc distribution builds with Django
Serve self-contained distribution builds of Swagger UI and Redoc with Django
either via runserver or collectstatic.

This Django app is an optional addition to drf-spectacular, but does not depend
on it. It may also be used independently.
2023-05-04T13:33:15+02:00 www/py-drf-spectacular Sane/flexible OpenAPI 3 schema generation for Django REST framework
This project has 3 goals:

* Extract as much schema information from DRF as possible.
* Provide flexibility to make the schema usable in the real world (not only
toy examples).
* Generate a schema that works well with the most popular client generators.

The code is a heavily modified fork of the DRF OpenAPI generator, which is/was
lacking all of the below listed features:

* Serializers modelled as components. (arbitrary nesting + recursion supported)
* @extend_schema decorator for customization of APIView, Viewsets,
function-based views, and @action
* Authentication support (DRF natives included, easily extendable)
* Custom serializer class support (easily extendable)
* SerializerMethodField() type via type hinting or @extend_schema_field
* i18n support, Tags extraction, Description extraction from docstrings
* Request/response/parameter examples, Callback operations
* Vendor specification extensions (x-*) in info, operations, parameters,
components, and security schemes
* Sane fallbacks and sane operation_id naming (based on path)
* Schema serving with SpectacularAPIView (Redoc and Swagger-UI views are
also available)
* Optional input/output serializer component split
2023-05-04T06:06:46+00:00 x11-wm/cage-devel Wayland kiosk (development snapshot)
Cage is a kiosk compositor for Wayland. A kiosk is a window manager
(in the X11 world) or compositor (in the Wayland world) that is
designed for a user experience wherein user interaction and activities
outside the scope of the running application are prevented. That is, a
kiosk compositor displays a single maximized application at a time and
prevents the user from interacting with anything but this application.
2023-05-04T11:11:49+09:00 devel/electron24 Build cross-platform desktop apps with JavaScript, HTML, and CSS
Build cross platform desktop apps with JavaScript, HTML, and CSS.

It's easier than you think.

If you can build a website, you can build a desktop app. Electron is a
framework for creating native applications with web technologies like
JavaScript, HTML, and CSS. It takes care of the hard parts so you can
focus on the core of your application.
2023-05-03T00:41:51-05:00 math/octave-forge-fileio Octave-forge package ${OCTAVE_PKGNAME}
The octave-forge package is the result of The GNU Octave Repositry project,
which is intended to be a central location for custom scripts, functions and
extensions for GNU Octave. contains the source for all the functions plus
build and install scripts.

This is fileio.

I/O function for files holding structured data, such as JSON and XML files.
2023-05-02T22:51:49-04:00 security/gpgme-qt Gpgme Qt6 bindings
2023-02-15T20:30:54+01:00 databases/mongodb70 Distributed document-oriented "NoSQL" database (7.0.x Branch)
Mongo (from "humongous") is a high-performance, open source,
schema-free, document-oriented database. A common name in the
"NOSQL" community.
2023-05-01T15:28:54+02:00 www/phpfpmtop Top-inspired processviewer for PHP-FPM
Top-inspired processviewer for PHP-FPM
2023-05-03T00:16:20+08:00 devel/py-pyxb-x Python W3C XML Schema Bindings
PyXB is a pure Python package that generates Python code for classes that
correspond to data structures defined by XMLSchema. In concept it is similar to
JAXB for Java and CodeSynthesis XSD for C++.
2023-04-22T19:47:46+02:00 security/tlsc TLS connect daemon
A simple socket proxy for connecting to TLS-enabled services.

This daemon will listen on sockets (typically on localhost) and forward
connecting clients to some remote host, adding TLS encryption.

It does the job in the simplest possible way, using all-standard options.
2023-05-01T13:26:19-05:00 security/py-iris-intelowl-module IntelOwl IRIS module
iris-intelowl-module is a IRIS processor module providing open-source threat
intelligence leveraging IntelOlw analyzers, to enrich indicators of compromise.
2023-05-01T16:53:40+02:00 audio/ebur128 Library implementing the EBU R128 loudness standard
Rust port of the libebur128 C library which implements the EBU R 128 standard
for loudness normalization produces the same results as the C library
2023-04-30T23:49:38-07:00 math/py-mnnpy MNN (Mutual Nearest Neighbors) correct in python
mnnpy is an implementation of MNN correct in python featuring low memory usage,
full multicore support and compatibility with the scanpy framework.
2023-04-30T16:50:39-05:00 security/py-iris-evtx-module Example of IRIS module, handling EVTX files
An interface module for Evtx2Splunk and Iris in order to ingest Microsoft EVTX
log files. The module is installed on IRIS by default. In case you needed a
procedure to install it by yourself, you can follow the one below.
2023-04-30T16:33:08-05:00 textproc/py-evtx2splunk Evtx to Splunk ingestor
Ingest EVTX files into a Splunk instance.

This tool is based on the work of :

Omer BenAmram
Blardy
Thanks to Ekto for its contribution.

Key features:

- Splunk HEC support with token auto-creation
- Splunk index auto-creation
- Multiprocessing support
- Caching for evtx reuse without reconverting
- Windows and Linux compatibility
- Rely on the great and fast evtx_dump Rust tool of Omer
- Evtx message resolutions from database

Note: evtx2splunk converts the EVTX to JSON and stores them in a temporary
place. Hence, up to the size of source EVTX can be created during the process.
These files are removed at the end of the process, except if keep_cache is
enabled.
2023-04-30T16:26:32-05:00 textproc/evtx A Fast parser for the Windows XML Event Log (EVTX) format
A cross-platform parser for the Windows XML EventLog format

Features:

- Implemented using 100% safe rust - and works on all platforms supported by
rust (that have stdlib).
- It's faster than any other implementation by order(s) of magnitude!
- Multi-threaded.
- Supports XML and JSON outputs, both being directly constructed from the token
tree and independent of each other (no xml2json conversion is performed!)
- Supports some basic recovery of missing records/chunks!
2023-04-30T15:53:44-05:00 textproc/py-splunk-hec Python class to submit events to Splunk HTTP Event Collector
This is a python class file for use with other python scripts to send events to
a Splunk http event collector.

Supported products:

Splunk v6.3.X+
Splunk v6.4.X+ for the raw input option
2023-04-10T19:33:30-04:00 archivers/py-zipstream-ng Modern and easy to use streamable zip file generator
zipstream-ng is a modern and easy to use streamable zip file
generator. It can package and stream many files and folders on the
fly without needing temporary files or excessive memory.

Includes the ability to calculate the total size of the stream
before any data is actually added (provided no compression is used).
This makes it ideal for use in web applications since the total
size can be used to set the `Content-Length` header without having
to generate the entire file first.

Features:
* Generates zip data on the fly as it's requested.
* Can calculate the total size of the resulting zip file before generation even
begins.
* Flexible API: Typical use cases are simple, complicated ones are possible.
* Supports zipping data from files, bytes, strings, and any other iterable
objects.
* Threadsafe: Won't mangle data if multiple threads concurrently add/read data
to/from the same stream.
* Includes a clone of Python's `http.server` module with zip support added.
Try `python -m zipstream.server`.
* Automatically uses Zip64 extensions, but only if they are required.
* No external dependencies.
2023-04-29T16:52:00-04:00 graphics/asciinema-agg Asciinema gif generator
agg is a command-line tool for generating animated GIF files from
asciicast v2 files produced by asciinema terminal recorder. It uses
the excellent gifski library to produce optimized, high quality GIF
output with accurate frame timing.
2023-04-29T09:18:21-04:00 net/py-speedometer Chart network TX/RX and file download rates on the console
Speedometer is a minimalistic python script that provides a TUI
interface to measure and display the speed of data across a network
connection or data being stored in a file.
2023-04-28T06:59:58-04:00 sysutils/imgurbash2 Upload or delete images and videos to imgur
imgurbash2 is a simple bash script that allows you to upload images
and videos to imgur. Once an image/video is uploaded, the link is
displayed on the terminal and copied to your clipboard.

Features:

* Upload remote HTTP/HTTPS images and videos to imgur.
* Upload multiple images and videos at one go.
* Upload images/videos to your album and to your account.
* Delete previously uploaded images/videos.
* Automatically images/videos deletion.
* Copy uploaded images/videos' URLs to clipboard.
2023-04-28T15:12:48-04:00 sysutils/llama Terminal file manager
llama is a simple and minimalistic file manager. It's a fast way to
navigate the filesystem, and a cd and ls replacement. It allows for
quick navigation with fuzzy searching and the cd-integration with
the shell is a one-liner.
2023-04-30T02:10:36-05:00 textproc/py-docx-generator Tool to generate docx report from docx template and json data
Tool to generate docx report from docx template and json data
2023-04-30T01:47:38-05:00 textproc/py-docxtpl Python docx template engine
python-docx-template has been created because python-docx is powerful for
creating documents but not for modifying them.

The idea is to begin to create an example of the document you want to generate
with microsoft word, it can be as complex as you want: pictures, index tables,
footer, header, variables, anything you can do with word. Then, as you are
still editing the document with microsoft word, you insert jinja2-like tags
directly in the document. You save the document as a .docx file (xml format).
it will be your .docx template file.

Now you can use python-docx-template to generate as many word documents you
want from this .docx template and context variables you will associate.
2023-04-29T23:24:29-05:00 textproc/py-docxcompose Python library for concatenating/appending Microsoft Word files.
docxcompose is a Python library for concatenating/appending Microsoft Word
(.docx) files.
2023-04-29T22:53:45-05:00 security/py-iris-vt-module IRIS Module enriching IOCs with VT insights
An interface module for VT and Iris to automatically enrich IOCs with VT
insight.
2023-04-29T22:46:55-05:00 security/py-iris-webhooks-module IRIS module offering support for webhooks
An interface module that allows to call webhooks from IRIS.
2023-04-29T22:31:31-05:00 security/py-iris-check-module A simple processor module for IRIS
An Iris Module that simply replies to every hooks
2023-04-29T22:24:10-05:00 security/py-iris-misp-module IRIS module interfacing MISP with IRIS
An interface module for MISP and Iris to automatically enrich IOCs with MISP
insight.
2023-04-29T22:14:19-05:00 security/py-iris-module-interface Base interface for modules of Iris
This Python package is used by IRIS modules to interact and extend IRIS
capabilities. It's the interface which module have to use to communicate with
the platform.
2023-04-29T19:37:32-05:00 graphics/py-sqlalchemy-imageattach SQLAlchemy extension for attaching images to entities
SQLAlchemy-ImageAttach is a SQLAlchemy extension for attaching images to entity
objects. It provides the following features:

- Storage backend interface
- Maintaining multiple image sizes
- Every image has its URL
- SQLAlchemy transaction aware
2023-04-29T19:32:06-05:00 devel/py-pyintelowl Python SDK and Command Line Client for interacting with IntelOwl API
Robust Python SDK and Command Line Client for interacting with IntelOwl's API.

Features

- Easy one-time configuration with self documented help and hints along the
way.
- Request new analysis for observables and files.
- Select which analyzers you want to run for every analysis you perform.
- Choose whether you want to HTTP poll for the analysis to finish or not.
- List all jobs or view one job in a prettified tabular form.
- List all tags or view one tag in a prettified tabular form.
- Tabular view of the analyzer_config.json and connector_config.json from
IntelOwl with RegEx matching capabilities.
2023-04-29T19:28:21-05:00 devel/py-click-creds Pluggable credentials storage and management for click cli apps
Pluggable credentials storage and management for click CLI applications.
2023-04-29T19:26:06-05:00 devel/py-tinynetrc Read and write netrc files in Python
tinynetrc uses the netrc module from the standard library under the hood and
adds a few improvements:

- Adds write functionality.
- Fixes a std lib bug with formatting a .netrc file.*
- Parses .netrc into dictionary values rather than tuples.
2023-04-29T18:52:00-05:00 devel/py-geocoder Python geocoder
Simple and consistent geocoding library written in Python
2023-04-29T18:50:32-05:00 devel/py-ratelim Makes it easy to respect rate limits
Ratelim is a simple Python library that limits the number of times a function
can be called during a time interval. It is particularly useful when using
online APIs, which commonly enforce rate limits.

Features

- Works in Py2 and Py3.
- Greedy and patient rate limiting.
- Preserves function signature.
2023-04-29T18:43:57-05:00 archivers/py-patool portable command line archive file manager
Patool is an archive file manager.

Various archive formats can be created, extracted, tested, listed, searched,
repacked and compared with patool. The advantage of patool is its simplicity in
handling archive files without having to remember a myriad of programs and
options.

The archive format is determined by the file(1) program and as a fallback by
the archive file extension.

patool supports 7z (.7z, .cb7), ACE (.ace, .cba), ADF (.adf), ALZIP (.alz),
APE (.ape), AR (.a), ARC (.arc), ARJ (.arj), BZIP2 (.bz2), CAB (.cab),
COMPRESS (.Z), CPIO (.cpio), DEB (.deb), DMS (.dms), FLAC (.flac), GZIP (.gz),
ISO (.iso), LRZIP (.lrz), LZH (.lha, .lzh), LZIP (.lz), LZMA (.lzma),
LZOP (.lzo), RPM (.rpm), RAR (.rar, .cbr), RZIP (.rz), SHN (.shn),
TAR (.tar, .cbt), XZ (.xz), ZIP (.zip, .jar, .cbz) and ZOO (.zoo) archive
formats. It relies on helper applications to handle those archive formats (for
example bzip2 for BZIP2 archives).

The archive formats TAR, ZIP, BZIP2 and GZIP are supported natively and do not
require helper applications to be installed.
2023-04-29T18:42:10-05:00 archivers/py-pyunpack unpack archive files in Python
unpack archive files in Python

Features:

- unpack archive files
- support passwords
- very simple interface
- command line interface and library

back-ends:

- zipfile: included in Python
- patool: It relies on helper applications to handle those archive formats (for
example bzip2 for BZIP2 archives). Supported formats: 7z (.7z), ACE (.ace),
ALZIP (.alz), AR (.a), ARC (.arc), ARJ (.arj), BZIP2 (.bz2), CAB (.cab),
compress (.Z), CPIO (.cpio), DEB (.deb), DMS (.dms), GZIP (.gz), LRZIP (.lrz),
LZH (.lha, .lzh), LZIP (.lz), LZMA (.lzma), LZOP (.lzo), RPM (.rpm),
RAR (.rar), RZIP (.rz), TAR (.tar), XZ (.xz), ZIP (.zip, .jar) and ZOO (.zoo)
2023-04-29T18:39:22-05:00 devel/py-entrypoint2 easy to use command-line interface for Python modules
entrypoint2 is an easy to use argparse based command-line interface for python
modules. It translates function signature and documentation to argparse
configuration.
2023-04-29T18:30:46-05:00 security/py-flask-bcrypt Flask extension that provides bcrypt hashing utilities for your application
Flask-Bcrypt is a Flask extension that provides bcrypt hashing utilities for
your application.

Due to the recent increased prevalence of powerful hardware, such as modern
GPUs, hashes have become increasingly easy to crack. A proactive solution to
this is to use a hash that was designed to be "de-optimized". Bcrypt is such a
hashing facility; unlike hashing algorithms such as MD5 and SHA1, which are
optimized for speed, bcrypt is intentionally structured to be slow.

For sensitive data that must be protected, such as passwords, bcrypt is an
advisable choice.
2023-04-29T17:47:57-05:00 security/py-iris-client Python client for DFIR-IRIS
dfir_iris_client offers a Python interface to communicate with IRIS.

It relies exclusively on the API, which means output of the methods are the
same as specified in the API reference.
2023-04-29T15:38:17+00:00 devel/py-versioningit Obtain package version from repo tags
versioningit replaces the need for (and will overwrite) the version keyword
to the setup() function, so you should remove any such keyword from your
setup.py/setup.cfg to reduce confusion.

[tool.versioningit.format]

# Format used when there have been commits since the most recent tag:
distance = "{base_version}.post{distance}+{vcs}{rev}"

# Format used when there are uncommitted changes:
dirty = "{base_version}+d{build_date:%Y%m%d}"

# Format used when there are both commits and uncommitted changes:
distance-dirty = "{base_version}.post{distance}+{vcs}{rev}.d{build_date:%Y%m%d}"
2023-04-26T10:40:48+02:00 lang/gcc13 GNU Compiler Collection 13
GCC, the GNU Compiler Collection, supports a number of languages.
This port installs the C, C++, and Fortran front ends as gcc13, g++13,
and gfortran13, respectively.
2023-04-29T01:08:03-05:00 security/caldera Automated Adversary Emulation Platform
CALDERA a cyber security platform designed to easily automate adversary
emulation, assist manual red-teams, and automate incident response.

It is built on the MITRE ATT&CK framework and is an active research project
at MITRE.

The framework consists of two components:

- The core system. This is the framework code, consisting of what is available
in this repository. Included is an asynchronous command-and-control (C2)
server with a REST API and a web interface.
- Plugins. These repositories expand the core framework capabilities and
providing additional functionality. Examples include agents, reporting,
collections of TTPs and more.
2023-04-28T11:02:35-10:00 databases/puppetdb8 PuppetDB storeconfigs backend
The PuppetDB storeconfigs backend
2023-04-28T11:02:35-10:00 databases/puppetdb-terminus8 PuppetDB storeconfigs backend terminus module
The PuppetDB storeconfigs backend terminus module.
2023-04-28T11:00:54-10:00 sysutils/puppetserver8 Puppet Server running in the JVM
Puppet master is a Ruby application that compiles configurations
for any number of Puppet agent nodes, using Puppet code and various
other data sources. (For more info, see Overview of Puppet's
Architecture.)

Puppet Server is an application that runs on the Java Virtual Machine
(JVM) and provides the same services as the classic Puppet master
application. It mostly does this by running the existing Puppet
master code in several JRuby interpreters, but it replaces some
parts of the classic application with new services written in
Clojure.
2023-04-28T10:59:56-10:00 sysutils/puppet8 Configuration management framework written in Ruby
Puppet lets you centrally manage every important aspect of your system using
a cross-platform specification language that manages all the separate
elements normally aggregated in different files, like users, cron jobs, and
hosts, along with obviously discrete elements like packages, services, and
files.
2023-04-29T00:38:32+01:00 net-im/teleirc Telegram/IRC bridge for use with any IRC channel and Telegram group
TeleIRC is a Go implementation of a Telegram <=> IRC bridge. TeleIRC
works with any IRC channel and Telegram group. It bridges messages
between a Telegram group and an IRC channel.
2023-04-29T00:35:13+01:00 irc/py-sopel Easy-to-use and highly extensible IRC Bot framework
Sopel is a simple, lightweight, open source, easy-to-use IRC Utility
bot, written in Python. It's designed to be easy to use, run and
extend.
2023-04-05T14:11:49+02:00 misc/trurl Command line tool for URL parsing and manipulation
Command line tool for URL parsing and manipulation.

It can be used as a complementary tool with `curl'.
2023-04-27T17:44:52-04:00 sysutils/catsit Process supervisor
The catsitd daemon is a process supervisor for FreeBSD and OpenBSD.
It is designed to supervise processes with the following behavior:

* The process runs in the foreground, not as a daemon.
* The process logs to standard output or standard error.
* The process handles errors by exiting and expects to be
restarted.
* The process indicates its reason for exiting with sysexits(3).
2023-04-27T22:57:19+02:00 net-mgmt/makenl FidoNet NodeList Generator Program
MakeNL is an open-sourced version of MakeNL, the Fido/FTN nodelist
processing program. It is used to process Fido/FTN nodelists for
submission to coordinators and/or for creation of nodelist files for
distribution. It is a near drop-in replacement for an existing
installation of MakeNL.
2023-04-26T16:41:18-07:00 devel/gum Tool for glamorous shell scripts
Gum provides highly configurable, ready-to-use utilities to help you write
useful shell scripts and dotfiles aliases with just a few lines of code. Gum
is designed to be embedded in scripts and supports all sorts of use cases.
Components are configurable and customizable to fit your theme and use case.
2023-04-28T17:39:48+08:00 devel/R-cran-chk Check User-Supplied Function Arguments
For developers to check user-supplied function arguments. It is
designed to be simple, fast and customizable. Error messages
follow the tidyverse style guide.
2023-04-28T15:30:28+09:00 devel/electron23 Build cross-platform desktop apps with JavaScript, HTML, and CSS
Build cross platform desktop apps with JavaScript, HTML, and CSS.

It's easier than you think.

If you can build a website, you can build a desktop app. Electron is a
framework for creating native applications with web technologies like
JavaScript, HTML, and CSS. It takes care of the hard parts so you can
focus on the core of your application.
2023-04-28T07:57:58+08:00 devel/rubygem-aws-sdk-osis Official AWS Ruby gem for Amazon OpenSearch Ingestion
Official AWS Ruby gem for Amazon OpenSearch Ingestion.
2023-04-28T07:57:58+08:00 databases/rubygem-pg14 Ruby interface to PostgreSQL library
rubygem-pg provides the module "pg", a Ruby interface to the
PostgreSQL Relational Database Management System, which
supersedes the old "postgres" module.
2023-04-28T07:57:57+08:00 devel/p5-Test-Future-IO-Impl Acceptance tests for Future::IO implementations
Test::Future::IO::Impl contains a collection of acceptance tests for
implementations of Future::IO.
2023-04-27T23:28:15+08:00 www/rubygem-ruby-openai OpenAI API for Ruby
Use the OpenAI API with Ruby!

Generate text with ChatGPT, transcribe and translate audio with Whisper, or
create images with DALL-E...
2023-04-27T23:28:12+08:00 textproc/rubygem-bourbon Library of pure Sass mixins and functions
Bourbon is a library of Sass mixins and functions that are designed to make you
a more efficient style sheet author.

It is ...
- Dependency-free: Bourbon is pure Sass.
- Human-readable: We aim for clarity over brevity.
- Lightweight: Zero output post-install and has no visual opinion.
2023-04-27T23:28:09+08:00 devel/rubygem-semver_dialects Parse, process and compare semantic versions
semver_dialects is a gem for generic semantic version matcher that supports
different semantic version dialects:
- pypi
- composer/packagist
- maven
- gem
- go
- npm
- nuget
- conan

semver_dialects ...
- provides a unified interface to the language specific dialects.
- matches semantic versions in a language agnostic way.
- is able to collapse a list of concrete version into version ranges.
- invert ranges.
- can cope with scattered, non-consecutive ranges.
- can parse and produce different version syntaxes.
- matches version gracefully and handles input versions/constraints in a
best-effort manner.
2023-04-27T23:28:08+08:00 devel/rubygem-google-apis-playcustomapp_v1 Simple REST client for Google Play Custom App Publishing API V1
This is a simple client library for version V1 of the Google Play Custom App
Publishing API. It provides:
- A client object that connects to the HTTP/JSON REST endpoint for the service.
- Ruby objects for data structures related to the service.
- Integration with the googleauth gem for authentication using OAuth, API keys,
and service accounts.
- Control of retry, pagination, and timeouts.
2023-04-27T23:28:08+08:00 devel/rubygem-google-apis-bigquery_v2 Simple REST client for BigQuery API V2
This is a simple client library for version V2 of the BigQuery API. It provides:
- A client object that connects to the HTTP/JSON REST endpoint for the service.
- Ruby objects for data structures related to the service.
- Integration with the googleauth gem for authentication using OAuth, API keys,
and service accounts.
- Control of retry, pagination, and timeouts.
2023-04-27T23:28:07+08:00 devel/rubygem-google-apis-androidpublisher_v3 Simple REST client for Google Play Android Developer API V3
This is a simple client library for version V3 of the Google Play Android
Developer API. It provides:
- A client object that connects to the HTTP/JSON REST endpoint for the service.
- Ruby objects for data structures related to the service.
- Integration with the googleauth gem for authentication using OAuth, API keys,
and service accounts.
- Control of retry, pagination, and timeouts.
2023-04-27T23:28:06+08:00 www/rubygem-httparty020 Ruby Library that Makes HTTP Fun Again
httparty is a Ruby library that makes HTTP fun again!

Its features:
* Easy get, post, put, delete requests
* Basic http authentication
* Default request query string parameters (i.e. for API keys that are needed on
each request)
* Automatic parsing of JSON and XML into ruby hashes based on response
content-type
2023-04-27T23:28:04+08:00 textproc/py-accessible-pygments Collection of accessible pygments styles
Accessible pygments themes includes a collection of accessible themes for
pygments based on multiple open-source syntax highlighting themes.

Note: What do we mean by accessible? In this context we are specially referring
to themes which meet the WCAG 2.1 criteria for color contrast. Some themes
included are also color-blind friendly.
2023-04-27T23:28:01+08:00 graphics/py-python-barcode Create standard barcodes with Python
python-barcode provides a simple way to create barcodes in Python.

There are no external dependencies when generating SVG files. Pillow is required
for generating images (e.g.: PNGs).
2023-04-27T23:28:00+08:00 devel/py-pdoc API Documentation for Python Projects
pdoc auto-generates API documentation that follows your project's Python module
hierarchy.

pdoc's main feature is a focus on simplicity: pdoc aims to do one thing and do
it well.

- Easy setup, no configuration necessary.
- Documentation is plain Markdown.
- First-class support for type annotations.
- Builtin web server with live reloading.
- Customizable HTML templates.
- Understands numpydoc and Google-style docstrings.
2023-04-27T20:00:06+08:00 textproc/typst Markup-based typesetting system
Typst is a new markup-based typsetting system that is designed to be as
powerful as LaTeX while being much easier to learn and use. Typst has:

Built-in markup for the most common formatting tasks
Flexible functions for everything else
A tightly integrated scripting system
Math typesetting, bibliography management, and more
Fast compile times thanks to incremental compilation
Friendly error messages in case something goes wrong
2023-04-26T22:42:34-04:00 devel/R-cran-pkgdepends Package Dependency Resolution and Downloads
Find recursive dependencies of 'R' packages from various sources. Solve the
dependencies to obtain a consistent set of packages to install. Download
packages, and install them. It supports packages on 'CRAN', 'Bioconductor' and
other 'CRAN-like' repositories, 'GitHub', package 'URLs', and local package
trees and files. It caches metadata and package files via the 'pkgcache'
package, and performs all 'HTTP' requests, downloads, builds and installations
in parallel. 'pkgdepends' is the workhorse of the 'pak' package.
2023-04-26T22:42:19-04:00 devel/R-cran-pkgsearch Search and Query CRAN R Packages
Search CRAN metadata about packages by keyword, popularity, recent activity,
package name and more. Uses the 'R-hub' search server, see <https://r-pkg.org>
and the CRAN metadata database, that contains information about CRAN packages.
Note that this is _not_ a CRAN project.
2023-04-26T15:53:59-05:00 x11/py-pyautogui lets Python control the mouse and keyboard, and other GUI automation tasks
PyAutoGUI is a cross-platform GUI automation Python module for human beings.
Used to programmatically control the mouse & keyboard.
2023-04-26T15:43:51-05:00 devel/py-pytweening A collection of tweening or easing functions
A collection of tweening / easing functions implemented in Python.
2023-04-26T22:41:00+02:00 sysutils/erdtree Filesystem and disk-usage analysis tool
erdtree is a modern, cross-platform, and multi-threaded filesystem and
disk-usage analysis tool. The following are some feature highlights:

- Respects hidden file and gitignore rules by default.
- Supports regular expressions and glob based searching by file-type.
- Supports Unix-based file permissions (Unix systems only).
- Comes with a variety of layouts.
- Support icons.
- Colorized with LS_COLORS.

You can think of erdtree as a combination of du, tree, find, and ls.
2023-04-26T15:39:34-05:00 devel/py-pymsgbox Python module for JavaScript-like message boxes
A simple, cross-platform, pure Python module for JavaScript-like message boxes.
2023-04-26T15:36:41-05:00 x11/py-pyscreeze cross-platform screenshot module for python
PyScreeze can take screenshots, save them to files, and locate images within
the screen. This is useful if you have a small image of, say, a button that
needs to be clicked and want to locate it on the screen.

Screenshot functionality requires the Pillow module. OS X uses the
screencapture command, which comes with the operating system. Linux/FreeBSD
uses the scrot command.
2023-04-26T15:32:07-05:00 x11/py-mouseinfo application to display XY position and RGB color information
An application to display XY position and RGB color information for the pixel
currently under the mouse. This is useful for GUI automation planning.
2023-04-26T19:20:51+00:00 devel/py-bps-restpy BreakingPoint REST API Python Wraper
Module for interfacing to BreakingPoint appliance. Let's you connect to their
appliances for simulating real-world legitimate traffic, DDoS, exploits,
malware, and fuzzing.

# Login to BPS box
bps = BPS(bps_system, bpsuser, bpspass)
bps.login()

print("Load a canned test: ")
bps.testmodel.load(canned_test_name)

print("Reserve Ports")
for p in port_list:
bps.topology.reserve([{'slot': slot_number, 'port': p, 'group': 2}])


print("Run test and Get Stats:")
test_id_json = bps.testmodel.run(modelname=canned_test_name, group=2)
testid = str( test_id_json["runid"] )
run_id = 'TEST-' + testid
print("Test Run Id: %s"%run_id)
2023-04-26T15:21:18+00:00 devel/py-simple-term-menu Creates simple menus for interactive command line programs
simple-term-menu creates simple menus for interactive command line programs. It
can be used to offer a choice of different options to the user. Menu entries
can be selected with the arrow, j/k, or emacs (C-n/C-p) keys. The module uses
the terminfo database to detect terminal features automatically and disables
styles that are not available. Currently, Linux and macOS are supported.

Usage: Create a menu with the default style

Create an instance of the class TerminalMenu and pass the menu entries as a
list of strings to the constructor. Call the show method to output the menu
and wait for keyboard input:

#!/usr/bin/env python3

from simple_term_menu import TerminalMenu

def main():
options = ["entry 1", "entry 2", "entry 3"]
terminal_menu = TerminalMenu(options)
menu_entry_index = terminal_menu.show()
print(f"You have selected {options[menu_entry_index]}!")

if __name__ == "__main__":
main()
2023-04-25T23:20:16-05:00 www/py-webdriver_manager provides the way to automatically manage drivers for different browsers
The main idea is to simplify management of binary drivers for different
browsers.

For now support:

ChromeDriver
EdgeChromiumDriver
GeckoDriver
IEDriver
OperaDriver

Compatible with Selenium 4.x and below.
2023-04-25T19:40:10-05:00 math/octave-forge-pkg-octave-doc Octave-forge package ${OCTAVE_PKGNAME}
The octave-forge package is the result of The GNU Octave Repositry project,
which is intended to be a central location for custom scripts, functions and
extensions for GNU Octave. contains the source for all the functions plus
build and install scripts.

This is pkg-octave-doc.

This package provides functions for generating HTML pages that
contain the help texts of the functions of an octave package. The package is
designed to work with installed packages and use their INDEX file for creating
the respective functions' HTML pages. The default layout is based on boootstrap
5 and it follows the design of the Octave Packages GitHub page.
2023-04-25T19:54:55+02:00 textproc/arianna e-book reader
An ebook reader and library management app supporting ".epub"
files. Arianna discovers your books automatically, and sorts them
by categories, genres and authors.
2023-04-23T21:20:21+02:00 multimedia/kasts KDE podcast app
Kasts is a convergent podcast application

Its main features are:

- Episode management through play queue
- Sync playback positions with other clients through gpodder.net
or gpodder-nextcloud
- Variable playback speed
- Search for podcasts
- Full system integration: e.g. inhibit system suspend while listening
2023-04-25T12:51:37-04:00 devel/R-cran-whoami Username, Full Name, Email Address, 'GitHub' Username of the Current User
Look up the username and full name of the current user, the current user's
email address and 'GitHub' username, using various sources of system and
configuration information.
2023-04-25T12:51:02-04:00 devel/R-cran-parsedate Recognize and Parse Dates in Various Formats, Including All ISO 8601 Formats
Parse dates automatically, without the need of specifying a format. Currently
it includes the git date parser. It can also recognize and parse all ISO 8601
formats.
2023-04-25T12:49:57-04:00 www/R-cran-shinyjs Easily Improve the User Experience of Your Shiny Apps in Seconds
Perform common useful JavaScript operations in Shiny apps that will greatly
improve your apps without having to know any JavaScript. Examples include:
hiding an element, disabling an input, resetting an input back to its original
value, delaying code execution by a few seconds, and many more useful functions
for both the end user and the developer. 'shinyjs' can also be used to easily
call your own custom JavaScript functions from R.
2023-04-25T17:10:59+02:00 net/trippy Network diagnostic tool inspired by mtr
Trippy combines the functionality of traceroute and ping and is designed
to assist with the diagnosis of network issues.
2023-04-25T11:15:43+02:00 lang/gcc14-devel GNU Compiler Collection 14
GCC, the GNU Compiler Collection, supports a number of languages.
This port installs the C, C++, and Fortran front ends as gcc14, g++14,
and gfortran14, respectively.
2023-04-25T11:21:42+00:00 sysutils/ntfs2btrfs NTFS to Btrfs in-place conversion utility
Ntfs2btrfs is a tool which does in-place conversion of Microsoft's NTFS
file system to the open-source file system Btrfs, much as btrfs-convert
does for ext2. The original file system image is saved as a reflink copy
at `image/ntfs.img', and can be deleted to free up space if you want to
keep the conversion.
2023-04-24T18:50:14+02:00 mail/datovka Qt re-implementation of Datovka
Qt re-implementation of Datovka.
2023-04-24T21:57:18+02:00 textproc/go-transifex-client Command line interface for Transifex
The Transifex Command-line Client (APIv3) is a command line tool that enables you
to easily manage your translations within a project without the need of an
elaborate UI system.

You can use the command line client to easily create new resources, map
locale files to translations and synchronize your Transifex project with
your local repository and vice verca. Translators and localization managers
can also use it to handle large volumes of translation files easily and
without much hassle.
2023-04-24T10:30:42+02:00 devel/p5-Mojo-Log-Clearable Log rotation role for Mojo::Log
Mojo::Log is a simple logger class. It holds a filehandle once it writes to
a log, and changing "path" in Mojo::Log does not open a new filehandle for
logging.

Mojo::Log::Role::Clearable is a role that provides a "clear_handle" method
and automatically calls it when "path" in Mojo::Log is modified, so the
logging handle is reopened at the new path.

The "clear_handle" method can also be used to reopen the logging handle
after log rotation.
2023-04-24T00:53:59+08:00 devel/py-immutabledict Immutable wrapper around dictionaries for Python3
A fork of the original frozendict, an immutable wrapper around dictionaries.
This library is a pure Python, MIT-licensed alternative to the new LGPL-3.0
licensed frozendict.

It implements the complete mapping interface and can be used as a drop-in
replacement for dictionaries where immutability is desired. The immutabledict
constructor mimics dict, and all of the expected interfaces (iter, len, repr,
hash, getitem) are provided. Note that an immutabledict does not guarantee the
immutability of its values, so the utility of hash method is restricted by
usage.

The only difference is that the copy() method of immutable takes variable
keyword arguments, which will be present as key/value pairs in the new,
immutable copy.
2023-04-23T21:47:02+08:00 astro/py-sunpy Python for Solar Physics
Sunpy is a Python software package that provides fundamental tools for
accessing, loading and interacting with solar physics data in Python.
It is the core library of the SunPy Project.
2023-04-23T21:10:22+08:00 ftp/py-parfive HTTP and FTP parallel file downloader
A parallel file downloader using asyncio. parfive can handle downloading
multiple files in parallel as well as downloading each file in a number
of chunks.
2023-04-23T20:08:28+08:00 www/moodle42 Course management system based on social constructionism
Moodle is a course management system (CMS) - a free, Open Source software
package designed using sound pedagogical principles, to help educators
create effective online learning communities. You can use it on any
computer you have handy (including webhosts), yet it can scale from a
single-teacher site to a 40,000-student University.
2023-04-09T01:29:48+00:00 net/wifi-firmware-rtw89-kmod
Firmware files for Realtek WiFi NICs supported by the rtw89 driver.

Currently supported chipsets:
- 8852a
- 8852b
- 8852c
2023-04-09T01:29:48+00:00 net/wifi-firmware-rtw88-kmod
Firmware files for Realtek WiFi NICs supported by the rtw88 driver.

Currently supported chipsets:
- RTL8822BE
- RTL8821CE
- RTL8822CE
- RTL8723DE
2023-04-09T01:29:48+00:00 net/wifi-firmware-mt76-kmod
Firmware files for Mediatek WiFi NICs supported by the mt76 driver.

Currently provides firmware for the following sub-drivers:
- mt7915
- mt7921
2023-04-09T01:29:48+00:00 net/wifi-firmware-base Firmware modules for ${FWDRV} ${FLAVOR} WiFi NIC
WiFi firmware build master port.
2023-04-09T01:29:48+00:00 net/wifi-firmware-ath11k-kmod
Firmware files for QCA WiFi NICs supported by the ath11k driver.

Currently only provides firmware for the PCI chipsets.
2023-04-09T01:29:48+00:00 net/wifi-firmware-ath10k-kmod
Firmware files for QCA WiFi NICs supported by the ath10k driver.

Currently only provides firmware for the PCI chipsets.
2023-04-22T10:34:38+01:00 devel/py-setuptools_scm7 Setuptools plugin to manage your versions by scm tags
Handles managing your python package versions in scm metadata instead of
declaring them as the version argument or in a scm managed file.
2023-04-21T23:01:38-10:00 devel/undead Obsolete Phobos modules upgraded to work with the latest D
Need an obsolete Phobos module? Here they are, back from the dead and upgraded
to work with the latest D.

modules included:

* std.bitarray
* std.date
* std.datebase
* std.dateparse
* std.regexp
* std.signals
* std.stream and friends
* std.xml

Some individual functions have been moved here rather than full Phobos modules.
They are:

* undead.doformat: Contains the doFormat function from std.format
* undead.string: Contains regex style pattern matching functions from
std.string
2023-04-21T14:46:44-05:00 math/octave-forge-velas Octave-forge package ${OCTAVE_PKGNAME}
The octave-forge package is the result of The GNU Octave Repositry project,
which is intended to be a central location for custom scripts, functions and
extensions for GNU Octave. contains the source for all the functions plus
build and install scripts.

This is velas.

VELAS is a user-friendly open-source toolbox for the visualization and
analysis of elastic anisotropy written in GNU Octave that can be used for any
crystal symmetry.
2023-04-20T18:17:47+02:00 mail/mailpit Mailpit development mail server
Mailpit is a multi-platform email testing tool & API for developers.

It acts as both an SMTP server, and provides a web interface to
view all captured emails.
2023-04-20T00:28:45-07:00 www/ghostunnel SSL/TLS proxy with mutual authentication for securing non-TLS services
Ghostunnel is a simple TLS proxy with mutual authentication support for securing
non-TLS backend applications.

Ghostunnel supports two modes, client mode and server mode. Ghostunnel in server
mode runs in front of a backend server and accepts TLS-secured connections,
which are then proxied to the (insecure) backend. A backend can be a TCP
domain/port or a UNIX domain socket. Ghostunnel in client mode accepts
(insecure) connections through a TCP or UNIX domain socket and proxies them to
a TLS-secured service. In other words, ghostunnel is a replacement for stunnel.
2023-04-20T08:23:30+02:00 graphics/inkscape-open-symbols SVG symbol sets that can be used as Inkscape symbols
These symbol libraries are sets of SVG symbols located in one SVG document and
usable with Inkscape. Symbols included:

* Google Material Design Icons
* Github Octicons
* Font Awesome Icons
* Fork Awesome
* Gnome Icon Theme Symbolic
* Automattic Genericons
* Taiga Icons
* Open Iconic
* Entypo
* Weatherize
* StateFace
* EmojiOne
* Dashicons
* CircuiTikZ
* Ionicons
* SJJB Map Icons
2023-04-19T21:26:22-05:00 security/py-dirhash Python module and CLI for hashing of file system directories
A lightweight python module and CLI for computing the hash of any directory
based on its files structure and content.

- Supports all hashing algorithms of Python's built-in hashlib module.
- Glob/wildcard (".gitignore style") path matching for expressive filtering of
files to include/exclude.
- Multiprocessing for up to 6x speed-up

The hash is computed according to the Dirhash Standard, which is designed to
allow for consistent and collision resistant generation/verification of
directory hashes across implementations.
2023-04-19T21:20:36-05:00 devel/py-scantree flexible recursive directory iterator
Recursive directory iterator supporting:

- flexible filtering including wildcard path matching
- in memory representation of file-tree (for repeated access)
- efficient access to directory entry properties (posix.DirEntry interface)
extended with real path and path relative to the recursion root directory
- detection and handling of cyclic symlinks
2023-04-19T17:02:14-05:00 security/py-aiohttp-security security for aiohttp.web
The library provides identity and authorization for aiohttp.web
2023-04-19T16:10:14-05:00 devel/py-aiohttp-apispec build and document REST APIs with aiohttp and apispec
aiohttp-apispec key features:

- docs and request_schema decorators to add swagger spec support out of the box
- validation_middleware middleware to enable validating with marshmallow
schemas from those decorators;
- SwaggerUI support.
- match_info_schema, querystring_schema, form_schema, json_schema,
headers_schema and cookies_schema decorators for specific request parts
validation.
2023-04-19T15:15:46-05:00 devel/py-donut-shellcode donut shellcode Python C extension
Donut is a position-independent code that enables in-memory execution of
VBScript, JScript, EXE, DLL files and dotNET assemblies. A module created by
Donut can either be staged from a HTTP server or embedded directly in the
loader itself. The module is optionally encrypted using the Chaskey block
cipher and a 128-bit randomly generated key. After the file is loaded and
executed in memory, the original reference is erased to deter memory scanners.
2023-04-19T14:55:52-05:00 archivers/py-pyminizip Library to create a password encrypted zip file in python
To create a password encrypted zip file in python. And the zip file is able to
extract in WINDOWS, GNU/Linux, BSD and others. This is a simple Minizip wrapper
of python.
2023-04-19T14:46:18-05:00 www/py-aiohttp-jinja2 template renderer for aiohttp.web (http server for asyncio)
jinja2 template renderer for aiohttp.web
2023-04-19T16:44:15+02:00 graphics/py-fotokilof GUI for ImageMagick and Wand
GUI for the most used ImageMagick functionalities for processing images.
2023-04-19T16:36:11+02:00 graphics/py-tkcolorpicker Color picker dialog for Tkinter
Color picker dialog for Tkinter.

This module contains a ColorPicker class which implements the color picker and
an askcolor function that displays the color picker and returns the chosen
color in RGB and HTML formats.
2023-04-19T18:54:11+08:00 devel/py-versioneer Easy VCS-based management of project version strings
Versioneer is a tool for managing a recorded version number in setuptools-based
python projects. The goal is to remove the tedious and error-prone "update the
embedded version string" step from your release process. Making a new release
should be as easy as recording a new tag in your version-control system, and
maybe making new tarballs.
2023-04-19T05:47:55+08:00 www/yarn-node20
2023-04-19T05:47:53+08:00 www/npm-node20
2023-04-19T05:37:18+08:00 devel/py-dask-histogram Histogramming with Dask
The boost-histogram library provides a performant object oriented API for
histogramming in Python. Building on the foundation of boost-histogram,
dask-histogram adds support for lazy calculations on Dask collections.
2023-04-19T05:37:17+08:00 devel/p5-Hash-Ordered Fast, pure-Perl ordered hash class
Hash::Ordered implements an ordered hash, meaning that it associates keys with
values like a Perl hash, but keeps the keys in a consistent order. Because it is
implemented as an object and manipulated with method calls, it is much slower
than a Perl hash. This is the cost of keeping order.

However, compared to other ordered hash implementations, Hash::Ordered is
optimized for getting and setting individual elements and is generally faster at
most other tasks as well. For specific details, see Hash::Ordered::Benchmarks.
2023-04-19T05:35:24+08:00 www/node20 V8 JavaScript for client and server
Node.js is a JavaScript runtime built on Chrome's V8 JavaScript engine. Node.js
uses an event-driven, non-blocking I/O model that makes it lightweight and
efficient. Node.js' package ecosystem, npm, is the largest ecosystem of open
source libraries in the world.
2023-04-19T05:35:58+08:00 net/gupnp-igd12 Library to handle UPnP IGD port mapping
This is a library to handle UPnP IGD port mapping.
2023-04-19T05:34:52+08:00 devel/swig40 Generate wrappers for calling C/C++ code from other languages
SWIG is a software development tool that connects programs written in C and C++
with a variety of high-level programming languages. SWIG is used with different
types of target languages including common scripting languages such as
Javascript, Perl, PHP, Python, Tcl and Ruby. The list of supported languages
also includes non-scripting languages such as C#, Common Lisp (CLISP, Allegro
CL, CFFI, UFFI), D, Go language, Java, Lua, Modula-3, OCAML, Octave and R. Also
several interpreted and compiled Scheme implementations (Guile, MzScheme/Racket,
Chicken) are supported. SWIG is most commonly used to create high-level
interpreted or compiled programming environments, user interfaces, and as a tool
for testing and prototyping C/C++ software. SWIG is typically used to parse
C/C++ interfaces and generate the 'glue code' required for the above target
languages to call into the C/C++ code. SWIG can also export its parse tree in
the form of XML and Lisp s-expressions.
2023-04-19T04:12:51+08:00 devel/py-resolvelib1 Resolve abstract dependencies into concrete ones
ResolveLib at the highest level provides a Resolver class that includes
dependency resolution logic. You give it some things, and a little information
on how it should interact with them, and it will spit out a resolution result.
2023-04-19T01:51:44+08:00 www/py-ticketutil Python ticketing utility supporting JIRA, RT, Redmine, Bugzilla, and ServiceNow
ticketutil is a Python module that allows you to easily interact with various
ticketing tools using their REST APIs. Currently, the supported tools are JIRA,
RT, Redmine, Bugzilla, and ServiceNow. All tools support HTTP Basic
authentication, while JIRA and RT also support Kerberos authentication.
Additionally, Bugzilla supports API key authentication and Jira supports
Personal Access Token authentication.

This module allows you to create tickets, add comments, edit ticket fields, and
change the status of tickets in each tool. Additional lower-level tool-specific
functions are supported - adding and removing watchers in JIRA, adding
attachments in JIRA, etc.
2023-04-19T01:51:42+08:00 security/py-pyhanko Tools for stamping and signing PDF files
The lack of open-source CLI tooling to handle digitally signing and stamping PDF
files was bothering me, so I went ahead and rolled my own.

Note: The working title of this project (and former name of the repository on
GitHub) was pdf-stamp, which might still linger in some references.
2023-04-19T01:51:39+08:00 devel/py-rapidfuzz2 Rapid fuzzy string matching in Python
Rapid fuzzy string matching in Python using various string metrics.
2023-04-19T01:51:38+08:00 devel/py-pytest-order pytest plugin to run your tests in a specific order
pytest-order is a pytest plugin that allows you to customize the order in which
your tests are run. It uses the marker order that defines when a specific test
shall run, either by using an ordinal number, or by specifying the relationship
to other tests.

pytest-order is a fork of pytest-ordering that provides additional features like
ordering relative to other tests.
2023-04-19T01:51:37+08:00 devel/py-pytest-cpp Use pytest runner to discover and execute C++ tests
pytest-cpp uses pytest runner to discover and execute C++ tests. It supports
Google Test, Boost.Test, and Catch2.

This brings several benefits:
- Allows you to run all your tests in multi-language projects with a single
command;
- Execute C++ tests in parallel using pytest-xdist plugin;
- Use --junitxml option to produce a single and uniform xml file with all your
test suite results;
- Filter which tests to run using standard test filtering capabilities, such as
by file names, directories, keywords by using the -k option, etc.;
2023-04-19T01:54:04+08:00 devel/py-pyproject-flake8 Monkey patching wrapper to connect flake8 with pyproject.toml configuration
pyproject-flake8 (pflake8) is a monkey patching wrapper to connect flake8 with
pyproject.toml configuration.
2023-04-19T01:51:36+08:00 devel/py-poetry-types Poetry plugin that adds/removes type stubs as dependencies
poetry-types is a plugin to poetry for the poetry plugin feature. It
installs/removes/updates typing stubs via following commands:
- poetry types add <package names>
- poetry types remove <package names>
- poetry types update <package names>
2023-04-19T01:51:35+08:00 devel/py-mystic Highly-constrained non-convex optimization and uncertainty quantification
The mystic framework provides a collection of optimization algorithms and tools
that allows the user to more robustly (and easily) solve hard optimization
problems. All optimization algorithms included in mystic provide workflow at the
fitting layer, not just access to the algorithms as function calls. mystic gives
the user fine-grained power to both monitor and steer optimizations as the fit
processes are running. Optimizers can advance one iteration with Step, or run to
completion with Solve. Users can customize optimizer stop conditions, where both
compound and user-provided conditions may be used. Optimizers can save state,
can be reconfigured dynamically, and can be restarted from a saved solver or
from a results file. All solvers can also leverage parallel computing, either
within each iteration or as an ensemble of solvers.
2023-04-19T01:51:34+08:00 devel/py-klepto Persistent caching to memory, disk, or database
klepto extends Python's lru_cache to utilize different keymaps and alternate
caching algorithms, such as lfu_cache and mru_cache. While caching is meant for
fast access to saved results, klepto also has archiving capabilities, for
longer-term storage. klepto uses a simple dictionary-sytle interface for all
caches and archives, and all caches can be applied to any Python function as a
decorator. Keymaps are algorithms for converting a function's input signature to
a unique dictionary, where the function's results are the dictionary value. Thus
for y = f(x), y will be stored in cache[x] (e.g. {x:y}).

klepto provides both standard and "safe" caching, where "safe" caches are slower
but can recover from hashing errors. klepto is intended to be used for
distributed and parallel computing, where several of the keymaps serialize the
stored objects. Caches and archives are intended to be read/write accessible
from different threads and processes. klepto enables a user to decorate a
function, save the results to a file or database archive, close the interpreter,
start a new session, and reload the function and it's cache.
2023-04-19T01:51:33+08:00 devel/py-check-jsonschema jsonschema CLI and pre-commit hook
check-jsonschema is a JSON Schema CLI and pre-commit hook built on jsonschema.
The schema may be specified as a local or remote (HTTP or HTTPS) file.

Remote files are automatically downloaded and cached if possible.
2023-04-19T01:51:33+08:00 devel/py-anndata Annotated data
anndata is a Python package for handling annotated data matrices in memory and
on disk, positioned between pandas and xarray. anndata offers a broad range of
computationally efficient features including, among others, sparse data support,
lazy operations, and a PyTorch interface.
2023-04-19T01:51:32+08:00 archivers/py-blosc2 Python wrapper for the C-Blosc2 library
C-Blosc2 is the new major version of C-Blosc, and is backward compatible with
both the C-Blosc1 API and its in-memory format. Python-Blosc2 is a Python
package that wraps C-Blosc2, the newest version of the Blosc compressor.

Currently Python-Blosc2 already reproduces the API of Python-Blosc, so it can be
used as a drop-in replacement. However, there are a few exceptions for a full
compatibility.

In addition, Python-Blosc2 aims to leverage the new C-Blosc2 API so as to
support super-chunks, multi-dimensional arrays (NDArray), serialization and
other bells and whistles introduced in C-Blosc2. Although this is always and
endless process, we have already catch up with most of the C-Blosc2 API
capabilities.

Note: Python-Blosc2 is meant to be backward compatible with Python-Blosc data.
That means that it can read data generated with Python-Blosc, but the opposite
is not true (i.e. there is no forward compatibility).
2023-04-18T15:26:23+02:00 misc/chatgpt-shell-cli Shell script to use OpenAI's ChatGPT and DALL-E from the terminal
A simple, lightweight shell script to use OpenAI's chatGPT and DALL-E from the
terminal without installing python or node.js. The script uses the official
ChatGPT model gpt-3.5-turbo with the OpenAI API endpoint /chat/completions.
You can also use the new gpt-4 model, if you have access.

The script supports the use of all other OpenAI models with the completions
endpoint and the images/generations endpoint for generating images.
2023-04-18T07:36:55+01:00 sysutils/dynamic_motd Dynamic /var/run/motd
dynamic_motd is a drop-in replacement for generating messages of the day on
FreeBSD 13.0 or later. During system startup, the file /var/run/motd is
replaced with a fifo whose content is generated by a user-configurable shell
script that is executed on each login. All other aspects of motd(5) are
preserved.
2023-04-17T10:50:02+02:00 games/fakesteak Implementation of the digital character rain as seen in "The Matrix"
Implementation of the digital character rain as seen in "The Matrix".

Some things you might like about fakesteak:

* Small footprint (low on RAM and disk usage)
* Good performance (low on CPU usage)
* Looks pretty close to the original (fading, glitches)
* Basic customization via command line options
* No dependencies (not even ncurses)
2023-04-17T01:46:21-07:00 science/py-HepMC3 Event record for High Energy Physics Monte Carlo generators/simulation
The HepMC package is an object oriented, C++ event record for High Energy
Physics Monte Carlo generators and simulation. The original code was written
by M. Dobbs and J.B. Hansen (Comput. Phys. Commun. 134 (2001) 41). Since the
first implementation, the package has undergone several modifications and in
particular, the latest HepMC3 series is a completely new rewrite using
currently available C++11 techniques.
2023-04-15T15:21:45+02:00 devel/stdman Formatted C++20 stdlib man pages
stdman is a tool that parses archived HTML files from cppreference and
generates groff-formatted manual pages for Unix-based systems.
The goal is to provide excellent formatting for easy readability.

This port installs pre-compiled man pages provided by upstream.
2023-04-14T21:52:41-07:00 devel/py-scikit-build-core Build backend for CMake based projects
scikit-build-core is a next generation Python CMake adaptor and Python API
for plugins.
2023-04-13T14:16:27+02:00 devel/massif-visualizer Graphical viewer for Massif data
massif-visualizer is a graphical viewer for Massif data that is
often easier to use than ms_print.
2023-04-12T16:34:25+03:00 textproc/rubygem-google-cloud-profiler-v2 Ruby Client to manage continous progiling information
Cloud Profiler is a statistical, low-overhead profiler that continuously gathers CPU
usage and memory-allocation information from your production applications.
It attributes that information to the application's source code, helping you identify
the parts of the application consuming the most resources, and otherwise illuminating
the performance characteristics of the code. Note that google-cloud-profiler-v2 is a
version-specific client library. For most uses, we recommend installing the main
client library google-cloud-profiler instead. See the readme for more details.
2023-04-10T11:06:30+03:00 security/rubygem-duo_api Ruby implementation of the Duo API
Duo_api_ruby uses the Ruby openssl extension for TLS operations.
All currently supported Ruby versions (2.7 and higher) support TLS 1.2 and 1.3.
2023-04-10T11:06:30+03:00 net/rubygem-net-protocol01 Abstruct interface for net-* client
Net::Protocol provides the abstruct interface for net-* client.
2023-04-12T00:16:40+00:00 x11-toolkits/gtk4-layer-shell GTK4 library for the Wayland layer-shell protocol
A library for using the Layer Shell Wayland protocol with GTK4. With
this library you can build desktop shell components such as panels,
notifications and wallpapers. You can use it to anchor your windows to
a corner or edge of the output, or stretch them across the entire
output. This Library is compatible with C, C++ and any language that
supports GObject introspection files (Python, Vala, etc).
2023-04-11T11:31:54+02:00 www/py-wcag-contrast-ratio Library for computing contrast ratios, as required by WCAG 2.0
A Python library for computing contrast ratios, as required by WCAG 2.0.
2023-04-10T15:23:26-05:00 www/bareos21-webui PHP-Frontend to manage Bareos over the web
The bareos-webui is a free software tool written in PHP, intended to monitor
and manage Bareos over the web.

The webui is based on Zend Framework 2, an open source framework for developing
web applications and services using PHP 5.3+ and makes extensive use of the
Twitter Bootstrap front-end framework.

The bareos-webui is licensed under AGPL Version 3.
2023-04-10T15:20:06-05:00 sysutils/bareos21-traymonitor Backup archiving recovery open sourced (traymonitor)
traymonitor inteface for Bareos.

Bareos (BackupArchivingRecoveryOpenSourced) is a reliable network open source
software to backup, archive and restore files from all major operating systems.
The fork was founded 2010 out of the bacula.org project. The fork has been
actively developed and many new features have been added.
2023-04-10T15:20:06-05:00 sysutils/bareos21-server Backup archiving recovery open sourced (server)
Bareos (BackupArchivingRecoveryOpenSourced) is a reliable network open source
software to backup, archive and restore files from all major operating systems.
The fork was founded 2010 out of the bacula.org project. The fork has been
actively developed and many new features have been added.
2023-04-10T15:20:06-05:00 sysutils/bareos21-client Backup archiving recovery open sourced (client)
2023-04-10T13:32:02-05:00 sysutils/py-python-bareos client library and tools for Bareos console access
python-bareos is a Python module to access a http://www.bareos.org backup
system
2023-04-10T13:21:45+02:00 databases/mariadb1011-server Multithreaded SQL database (server)
MariaDB is a database server that offers drop-in replacement functionality
for MySQL. MariaDB is built by some of the original authors of MySQL, with
assistance from the broader community of Free and open source software
developers. In addition to the core functionality of MySQL, MariaDB offers
a rich set of feature enhancements including alternate storage engines,
server optimizations, and patches.

MariaDB is primarily driven by developers at Monty Program, a company
founded by Michael "Monty" Widenius, the original author of MySQL, but
this is not the whole story about MariaDB. On the "About MariaDB" page you
will find more information about all participants in the MariaDB community,
including storage engines XtraDB and PBXT.
2023-04-10T13:21:45+02:00 databases/mariadb1011-client Multithreaded SQL database (client)
2023-04-10T10:55:30+02:00 www/vaultwarden-web_vault Vaultwarden WebUI
This is the Bitwarden web vault with the patches to make it work
with security/vaultwarden.
2023-04-10T04:39:13+08:00 net/rubygem-net-ldap017 Pure Ruby LDAP support library with most client features
Net::LDAP is an LDAP support library written in pure Ruby. It supports most
LDAP client features and a subset of server features as well.

* Standards-based (going for RFC 4511)
* Portable: 100% Ruby
2023-04-10T04:39:09+08:00 devel/py-opentelemetry-api OpenTelemetry Python API
This library provides Python API for OpenTelemetry project.
2023-04-10T04:39:08+08:00 devel/py-livemark Data presentation framework for Python
Data presentation framework for Python that generates static sites from extended
Markdown with interactive charts, tables, scripts, and other features.

Purpose:
- Data Journalism: Livemark provides a complete toolset for working with data,
starting from data extraction and ending with a published website containing
interactive charts, tables, and other features.
- Software Education: Livemark is perfectly suited for writing education
materials as it uses code execution model in markdown documents. It solves a
range of problems with testing and having your code example up-to-date.
- Python Development: Livemark can be used in software development as a helper
tool for working on Python projects. It provides an ability to create
documentation sites and works as a task runner.
2023-04-10T04:39:07+08:00 devel/py-datasette Open source multi-tool for exploring and publishing data
Datasette is a tool for exploring and publishing data. It helps people take data
of any shape or size and publish that as an interactive, explorable website and
accompanying API.

Datasette is aimed at data journalists, museum curators, archivists, local
governments, scientists, researchers and anyone else who has data that they wish
to share with the world.
2023-04-10T04:39:06+08:00 databases/py-redis3 Python client for Redis key-value store
This is the Python interface to the Redis key-value store.
2023-04-09T11:55:35-07:00 finance/py-python-binance Binance REST API python implementation
python-binance is an unofficial Python wrapper for the Binance exchange REST
API v3. I am in no way affiliated with Binance, use at your own risk.

It is suitable to automate interactions with Binance.
2023-04-09T21:17:02+08:00 textproc/rubygem-loofah219 Library for manipulating HTML/XML documents and fragments
Loofah is a general library for manipulating HTML/XML documents and fragments.
It's built on top of Nokogiri and libxml2, so it's fast and has a nice API.
Loofah excels at HTML sanitization (XSS prevention). It includes some nice HTML
sanitizers, which are based on HTML5lib's whitelist.
2023-04-09T21:17:00+08:00 devel/rubygem-aws-sdk-vpclattice Official AWS Ruby gem for Amazon VPC Lattice
Official AWS Ruby gem for Amazon VPC Lattice.
2023-04-09T21:16:59+08:00 devel/rubygem-aws-sdk-s31119 Official AWS Ruby gem for Amazon Simple Storage Service (Amazon S3)
Official AWS Ruby gem for Amazon Simple Storage Service (Amazon S3).
2023-04-09T21:16:58+08:00 devel/rubygem-aws-sdk-ivsrealtime Official AWS Ruby gem for Amazon Interactive Video Service RealTime (ivsrealtime)
Official AWS Ruby gem for Amazon Interactive Video Service RealTime
(ivsrealtime).
2023-04-09T21:16:57+08:00 devel/rubygem-aws-sdk-core3170 AWS SDK for Ruby - Core
Provides API clients for AWS. This gem is part of the official AWS SDK for
Ruby.
2023-04-09T21:16:56+08:00 math/py-ml-dtypes Stand-alone implementation of several NumPy dtype extensions
ml_dtypes is a stand-alone implementation of several NumPy dtype extensions used
in machine learning libraries.
2023-04-09T21:16:52+08:00 devel/py-py-partiql-parser Pure Python PartiQL Parser
py-partiql-parser is a tokenizer/parser/executor for the PartiQL-language, in
Python.
2023-04-09T21:16:51+08:00 devel/py-jupyterlab-lsp Coding assistance for JupyterLab with Language Server Protocol
Language Server Protocol integration for Jupyter(Lab)
2023-04-09T21:16:50+08:00 devel/py-jupyter-lsp Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server
Multi-Language Server WebSocket proxy for your Jupyter notebook or lab server.
2023-04-09T21:16:49+08:00 devel/py-flake8_simplify flake8 plugin which checks for code that can be simplified
flake8-simplify is a flake8 plugin that helps you simplify your code.
2023-04-09T21:16:49+08:00 devel/py-flake8-pyi Plugin for flake8 to enable linting .pyi stub files
flake8-pyi is a plugin for Flake8 that provides specializations for type hinting
stub files, especially interesting for linting typeshed.
2023-04-09T21:16:48+08:00 devel/py-flake8-comprehensions flake8 plugin to help you write better list/set/dict comprehensions
flake8-comprehensions is a flake8 plugin that helps you write better
list/set/dict comprehensions.
2023-04-09T21:16:47+08:00 devel/py-ast-decompiler Python module to decompile AST to Python code
ast_decompiler is a module for generating Python code given an AST.
2023-04-07T21:50:42-07:00 misc/aichat Using ChatGPT/GPT-3.5/GPT-4 in the terminal
AIChat is an application that allows to use
ChatGPT/GPT-3.5/GPT-4 in the terminal.
2023-04-07T07:29:12+00:00 x11-wm/xdgmenumaker Generates XDG menus for several window managers
xdgmenumaker is a command line tool, written in Python, that generates
application menus using XDG information, by scanning *.desktop files in
all $XDG_DATA_DIRS/applications directories. Applications are sorted
according to the main categories as specified by freedesktop.org.

Menu entries that are generated by xdgmenumaker are localized according
to the running user's locale settings.
2023-04-06T16:06:49+00:00 audio/mousai Identify songs in seconds
Discover songs you are aching to know with an easy-to-use interface.

Mousai is a simple application that can identify songs similar to Shazam. Just
click the listen button, and then wait a few seconds. It will magically return
the title and artist of that song!

Note: This uses the API of audd.io, so it is necessary to log in to their site
to get more trials.

Why you will love Mousai?
* Recognize songs within seconds or save for later when offline
* Use microphone or desktop audio
* Build a repertoire of recognized songs
* Quickly preview the song within the interface
* Browse and listen the song from different providers
* Easy-to-use user interface
2023-04-06T13:54:54+00:00 net/downzemall Multi-protocol standalone download manager
DownZemAll! is a multi-platform mass download manager. It helps one to
select, organize, prioritize, and run many downloads in parallel.

Based on the Qt framework, DownZemAll! is written in C/C++ and supports
various download types (regular files, video streams, torrents).
2023-04-06T12:32:54+02:00 archivers/par2cmdline-turbo Tools for using Parity v2 Archive files using ParPar backend
Parity v2 Archive create/verify/recover using ParPar backend

This is a simple fork of par2cmdline which replaces core computation routines
with ParPar's processing backend, improving par2cmdline's performance on
x86/ARM platforms.
2023-03-07T22:30:00+00:00 net-im/gtkcord4 Discord client written in go and gtk4
Discord client written in go and gtk4
2023-04-06T02:40:59+00:00 x11/sxmo-wayout Output simple text to a Wayland desktop widget
Wayout takes text from standard input and outputs it to a desktop-widget
on Wayland desktops. Periodic updates are supported; e.g. newline-separated
input or any other delimiter of choice. We call this a feed. The desktop
widget can be shown either on top (OSD-like functionality) or below other
windows.

A Wayland compositor must implement the Layer-Shell and XDG-Output for wayout
to work.

Features:
- Allow updating from standard input at a regular interval; custom delimiters
- Configurable colours/border/position/fonts
- Supports the pango markup language for text markup/colours.
2023-03-05T08:08:20+00:00 x11/hybrid-bar Status bar focused on wlroots Wayland compositors
Hybrid Bar is a simple status bar focused on wlroots Wayland compositors.

It supports:
- Straight-forward configuration;
- Labels with shell commands (+ listen support);
- Spacings (a.k.a. Separators if styled);
- Boxes with child widgets;
- Custom update-rate for dynamic labels;
- Cava;
- Buttons with shell commands;
- Tooltips for buttons and labels;
- Markup for buttons and labels;
- Top and Bottom pinning;
- Transparency (+ blur if your compositor allows for blurring surface layers);
- Experimental system tray via "stray";
- Different monitors for each configuration
2023-04-06T03:06:17+07:00 security/cpfx PFX decoder for CryptoPro GOST R 34.10-2012 implementation
PFX decoder for CryptoPro GOST R 34.10-2012 implementation.

No support for deprecated GOST R 34.10-2001.
2023-04-06T03:04:12+07:00 security/pygost Pure Python 2.7/3.x GOST cryptographic functions library
PyGOST is pure Python 2.7/3.x GOST cryptographic functions library.
Currently supported algorithms are:

GOST 28147-89 (RFC 5830) block cipher with ECB, CNT (CTR), CFB, MAC,
CBC (RFC 4357) modes of operation
various 28147-89-related S-boxes included
GOST R 34.11-94 hash function (RFC 5831)
GOST R 34.11-94 based PBKDF2 function
GOST R 34.11-2012 Streebog hash function (RFC 6986)
GOST R 34.11-2012 based PBKDF2 function (R 50.1.111-2016)
GOST R 34.10-2001 (RFC 5832) public key signature function
GOST R 34.10-2012 (RFC 7091) public key signature function
various 34.10 curve parameters included
Coordinates conversion from twisted Edwards to Weierstrass form and vice versa
VKO GOST R 34.10-2001 key agreement function (RFC 4357)
VKO GOST R 34.10-2012 key agreement function (RFC 7836)
28147-89 and CryptoPro key wrapping (RFC 4357)
28147-89 CryptoPro key meshing for CFB and CBC modes (RFC 4357)
RFC 4491 (using GOST algorithms with X.509) compatibility helpers
GOST R 34.12-2015 128-bit block cipher Kuznechik (RFC 7801)
GOST R 34.12-2015 64-bit block cipher Magma
GOST R 34.13-2015 padding methods and block cipher modes of operation (ECB,
CTR, OFB, CBC, CFB, MAC), ISO 10126 padding
MGM AEAD mode for 64 and 128 bit ciphers (RFC 9058)
CTR-ACPKM, OMAC-ACPKM-Master modes of operation (R 1323565.1.017-2018)
KExp15/KImp15 key export/import functions (R 1323565.1.017-2018)
KDF_GOSTR3411_2012_256, KDF_TREE_GOSTR3411_2012_256 (R 50.1.113-2016)
KEG export key generation function (R 1323565.1.020-2018)
PEP247-compatible hash/MAC functions
2023-04-06T03:00:29+07:00 devel/pyderasn Strict and fast ASN.1 DER/CER/BER library for Python
PyDERASN -- strict and fast ASN.1 DER/CER/BER library for Python

* BER/CER/DER decoding, strict DER validation, DER/CER encoding
* Basic ASN.1 data types (X.208): BOOLEAN, INTEGER, BIT STRING, OCTET
STRING, NULL, OBJECT IDENTIFIER, ENUMERATED, all strings, UTCTime,
GeneralizedTime, CHOICE, ANY, SEQUENCE (OF), SET (OF)
* Size constraints checking
* Working with sequences as high level data objects with ability to
(un)marshall them
* Aimed to be complaint with X.690-201508
* Streaming decoding and encoding capabilities, allowing working with
very small memory footprint
* Python 3.5+ compatibility
* Automatic decoding of DEFINED BY fields
* Ability to know exact decoded objects offset and lengths in the binary
* Ability to allow BER-encoded data with knowing if any of specified
field has either DER or BER encoding (or possibly indefinite-length
encoding)
* Ability to use mmap-ed files, memoryviews, iterators, 2-pass DER
encoding mode and CER encoder dealing with the writer, giving ability
to create huge ASN.1 encoded files with very little memory footprint
* Ability to decode files in event generation mode, without the need to
keep all the data and decoded structures in the memory
* __slots__, copy.copy() friendliness
* Workability with pickle
* Cython compatibility
* Descriptive errors, with decode paths
* Pretty printer and command-line decoder, that could conveniently
replace utilities like either dumpasn1 or openssl asn1parse
2023-04-06T01:07:50+08:00 textproc/rubygem-rouge3 Simple, easy-to-extend drop-in replacement for pygments
Rouge aims to a be a simple, easy-to-extend drop-in replacement for
pygments.
2023-04-06T01:07:47+08:00 security/rubygem-rasn1 Pure ruby ASN.1 library
Rasn1 is a ruby ASN.1 library to encode, parse and decode ASN.1 data in DER
format.
2023-04-06T01:07:44+08:00 net/rubygem-packetgen Network packet manipulation library
PacketGen provides simple ways to generate, send and capture network packets.
2023-04-06T01:07:40+08:00 net/rubygem-interfacez Simplified network interface API
Interfacez provides simplified network interfaces API.
2023-04-06T01:07:36+08:00 devel/rubygem-aws-sdk-internetmonitor Official AWS Ruby gem for Amazon CloudWatch Internet Monitor
Official AWS Ruby gem for Amazon CloudWatch Internet Monitor.
2023-04-06T01:07:35+08:00 textproc/py-mistletoe Fast, extensible Markdown parser in pure Python
mistletoe is a Markdown parser in pure Python, designed to be fast,
spec-compliant and fully customizable.

Apart from being the fastest CommonMark-compliant Markdown parser implementation
in pure Python, mistletoe also supports easy definitions of custom tokens.
Parsing Markdown into an abstract syntax tree also allows us to swap out
renderers for different output formats, without touching any of the core
components.

Remember to spell mistletoe in lowercase!
2023-04-06T01:07:32+08:00 security/py-detect-secrets Tool for detecting secrets in the codebase
detect-secrets is an aptly named module for (surprise, surprise) detecting
secrets within a code base.

However, unlike other similar packages that solely focus on finding secrets,
this package is designed with the enterprise client in mind: providing a
backwards compatible, systematic means of:
1. Preventing new secrets from entering the code base,
2. Detecting if such preventions are explicitly bypassed, and
3. Providing a checklist of secrets to roll, and migrate off to a more secure
storage.

This way, you create a separation of concern: accepting that there may currently
be secrets hiding in your large repository (this is what we refer to as a
baseline), but preventing this issue from getting any larger, without dealing
with the potentially gargantuan effort of moving existing secrets away.

It does this by running periodic diff outputs against heuristically crafted
regex statements, to identify whether any new secret has been committed. This
way, it avoids the overhead of digging through all git history, as well as the
need to scan the entire repository every time.
2023-04-06T01:07:29+08:00 devel/py-visidata Terminal interface for exploring and arranging tabular data
VisiData provides a terminal interface for exploring and arranging tabular data.
It supports tsv, csv, sqlite, json, xlsx (Excel), hdf5, and many other formats.
2023-04-06T01:07:28+08:00 devel/py-requirements-detector Find and list requirements of a Python project
Requirements Detector is a simple Python tool which attempts to find and list
the requirements of a Python project.

When run from the root of a Python project, it will try to ascertain which
libraries and the versions of those libraries that the project depends on.

It uses the following methods in order, in the root of the project:
1. Parse setup.py (if this is successful, the remaining steps are skipped)
2. Parse pyproject.yoml (if a tool.poetry.dependencies section is found, the
remaining steps are skipped)
3. Parse requirements.txt or requirements.pip
4. Parse all *.txt and *.pip files inside a folder called requirements
5. Parse all files in the root folder matching *requirements*.txt or reqs.txt
(so for example, pip_requirements.txt would match, as would
requirements_common.txt)
2023-04-06T01:07:27+08:00 devel/py-poetry-semver Semantic versioning library for Python
Poetry SemVer provides a semantic versioning library for Python. It is initially
part of the Poetry codebase.
2023-04-06T01:07:26+08:00 devel/py-pdm-backend Build backend used by PDM that supports latest packaging standards
This is the backend for PDM projects that is fully-compatible with PEP 517 spec,
but you can also use it alone. It reads the metadata of PEP 621 format and
coverts it to Core metadata.
2023-04-06T01:07:25+08:00 devel/py-jupyter-server-terminals Jupyter Server Extension Providing Terminals
Jupyter Server Terminals is a Jupyter Server Extension providing support for
terminals.
2023-04-06T01:07:24+08:00 devel/py-frictionless-ckan-mapper Library for mapping CKAN metadata from/to Frictionless metadata
Frictionless CKAN Mapper is a library for mapping CKAN metadata from/to
Frictionless metadata.

The library has zero dependencies (not even on Data Package libs). You can use
it directly or use it for inspiration. Detailed outline of the algorithm is in
the docs or you can read the code.
2023-04-06T01:07:23+08:00 devel/py-dodgy Search for dodgy looking lines in Python code
Dodgy is a very basic tool to run against your codebase to search for "dodgy"
looking values. It is a series of simple regular expressions designed to detect
things such as accidental SCM diff checkins, or passwords or secret keys hard
coded into files.

While this is primarily aimed at open source projects (for whom a publicly
available secret key is pretty dangerous), it can also be used in private
projects, with the caveat that it will point out things which are not a problem
for private projects and is not configurable enough currently to change that.

Another note - this tool is probably best run pre-commit, since it will
hopefully prevent dodgy things being checked in. To automatically execute before
a commit use a git pre-commit hook.
2023-04-06T01:07:22+08:00 databases/py-fastparquet Python support for Parquet file format
fastparquet is a python implementation of the parquet format, aiming integrate
into python-based big data work-flows. It is used implicitly by the projects
Dask, Pandas and intake-parquet.

We offer a high degree of support for the features of the parquet format, and
very competitive performance, in a small install size and codebase.
2023-04-06T01:07:21+08:00 archivers/py-sozipfile Fork of Python zipfile module, adding generation of sozip optimization
sozipfile is a fork of Python zipfile module, from its implementation in CPython
3.11, which implements the SOZip optimization, when writing deflate compressed
files whose size exceeds the chunk size (defaults to 32768 bytes).
2023-04-06T01:11:34+08:00 archivers/py-cramjam Thin Python bindings to de/compression algorithms in Rust
Extremely thin Python bindings to de/compression algorithms in Rust. Allows for
using algorithms such as Snappy, without any system dependencies.

This is handy when being used in environments like AWS Lambda, where installing
packages like python-snappy becomes difficult because of system level
dependencies.
2023-04-06T01:07:20+08:00 graphics/cgif GIF encoder written in C
CGIF is a fast and lightweight GIF encoder that can create GIF animations and
images. Summary of the main features:
- user-defined global or local color-palette with up to 256 colors (limit of the
GIF format)
- size-optimizations for GIF animations:
- option to set a pixel to transparent if it has identical color in the
previous frame (transparency optimization)
- do encoding just for the rectangular area that differs from the previous
frame (width/height optimization)
- fast: a GIF with 256 colors and 1024x1024 pixels can be created in below 50 ms
even on a minimalistic system
- MIT license (permissive)
- different options for GIF animations: static image, N repetitions, infinite
repetitions
- additional source-code for verifying the encoder after making changes
- user-defined delay time from one frame to the next (can be set independently
for each frame)
- source-code conforms to the C99 standard
2023-04-06T01:07:18+08:00 devel/libddwaf Datadog WAF engine
libddwaf is Datadog's implementation of a Web Application Firewall (WAF) engine,
with a goal of low performance and memory overhead, and embeddability in a wide
variety of language runtimes through a C API.
2023-04-04T17:29:49+03:00 misc/dlib-models Trained model files for dlib example programs
Dlib is a modern C++ toolkit containing machine learning algorithms
and tools for creating complex software in C++ to solve real world
problems. This packages provides trained models for various dlib algorithms.
2023-04-04T21:03:18+08:00 www/py-django42 High-level Python Web Framework
Django is a high-level Python Web framework that encourages rapid development
and clean, pragmatic design.

Developed and used over the past two years by a fast-moving online-news
operation, Django was designed from scratch to handle two challenges: the
intensive deadlines of a newsroom and the stringent requirements of experienced
Web developers. It has convenient niceties for developing content-management
systems, but it's an excellent tool for building any Web site.
2023-04-03T17:14:33+03:00 ports-mgmt/packagekit-qt DBUS packaging abstraction layer (Qt bindings)
PackageKit is a DBUS abstraction layer that allows the session user to manage
packages in a secure way using a cross-distro, cross-architecture API. This
library provides Qt-styled API to PackageKit.
2023-04-03T17:06:36+03:00 security/howdy Windows Hello(TM) style authentication provider
Howdy is an authentication tool that allows you to unlock your desktop
session using your webcam. It uses facial recognition to authenticate and
unlock the session.
2023-04-03T15:20:11+02:00 net-mgmt/fence-agents OCF Compliant Fence Agents
Fence agents were developed as device "drivers" which are able to prevent
computers from destroying data on shared storage.
Their aim is to isolate a corrupted computer, using one of three methods:

- Power - A computer that is switched off cannot corrupt data, but it is
important to not do a "soft-reboot" as we won't know if this is possible.
This also works for virtual machines when the fence device is a hypervisor.
- Network - Switches can prevent routing to a given computer, so even if a
computer is powered on it won't be able to harm the data.
- Configuration - Fibre-channel switches or SCSI devices allow us to limit who
can write to managed disks.

This is used by the Pacemaker cluster resource management.
2023-04-02T10:50:24-07:00 lang/opensycl Multi-backend implementation of SYCL for CPUs and GPUs
Open SYCL is a modern SYCL implementation targeting CPUs and GPUs from all major
vendors that supports many use cases and approaches for implementing SYCL.
2023-04-02T14:38:46-03:00 www/py-aiohttp-oauthlib Oauthlib for aiohttp clients
Oauthlib for aiohttp clients

Library integrating OAuthlib from Requests into the AIOHTTP Asynchronous
HTTP Client/Server framework.
2023-02-25T01:36:29+00:00 mail/dovecot-xaps Apple push notifications plugin for dovecot
Apple push notifications plugin for dovecot.

Together with net/xapsd this will enable push email
for iOS devices that talk to your dovecot IMAP server.
2023-03-29T16:43:20+02:00 x11-themes/wpgtk Colorscheme, wallpaper and template manager
wpgtk is a color-scheme manager with a template system which lets you
create templates from any text file and will replace keywords on it when
you change your theme, delivering high customizing power.

And also, for those who are not into auto-generated color-schemes, you
will be happy to know that wpgtk includes all the preset themes that
pywal does, so that's around 200+ themes to play around with, that you
can also modify to get really readable and cool results!
2023-03-29T14:40:44+02:00 graphics/pywal Generate and change color-schemes on the fly
Pywal is a tool that generates a color palette from the dominant colors
in an image. It then applies the colors system-wide and on-the-fly in
all of your favourite programs.

There are currently 5 supported color generation backends, each
providing a different palette of colors from each image. You're bound to
find an appealing color-scheme.

Pywal also supports predefined themes and has over 250 themes built-in.
You can also create your own theme files to share with others.

The goal of Pywal was to be as out of the way as possible. It doesn't
modify any of your existing configuration files. Instead it works around
them and provides tools to integrate your system as you see fit.

Terminal emulators and TTYs have their color-schemes updated in
real-time with no delay. With minimal configuration this functionality
can be extended to almost anything running on your system.
2023-03-31T08:29:12+00:00 devel/py-setuptools-declarative-requirements Setuptools: specify requirements using requirements files
Declarative setuptools Config Requirements Files Support

This projects adds the ability for projects using setuptools
declarative configuration to specify requirements using requirements
files.
2023-03-30T08:13:59-07:00 science/py-qiskit-dynamics Qiskit ODE solver
Qiskit Dynamics is an open-source project for building, transforming, and
solving time-dependent quantum systems in Qiskit.

The goal of Qiskit Dynamics is to provide access to different numerical methods
for solving differential equations, and to automate common processes typically
performed by hand, e.g. applying frame transformations or rotating wave
approximations to system and control Hamiltonians.
2023-03-30T23:56:35+02:00 devel/datovka Qt re-implementation of Datovka
Qt re-implementation of Datovka.
2023-03-30T23:34:17+02:00 devel/libdatovka ISDS client library
This is client library for accessing SOAP services of ISDS (Data Box Information
System) as defined in Czech ISDS Act (300/2008 Coll.)
2023-03-30T22:47:39+02:00 net/rustdesk-server Self hosted RustDesk server
RustDesk-server is a self hosted server for the RustDesk remote
desktop software.
2023-03-30T22:42:54+02:00 sysutils/xxd Hexdump and reverse hexdump utility from vim distribution
Standalone xxd utility from the vim editor distribution.

Xxd creates an hex dump of a given file or standard input.
It can also convert a hex dump back to its original binary form.
2023-03-30T08:13:59-07:00 devel/py-multiset Implementation of a multiset
The multiset package provides a multiset implementation for python.

A multiset is similar to the builtin set, but it allows an element to occur
multiple times. It is an unordered collection of elements which have to be
hashable just like in a set. It supports the same methods and operations as set
does, e.g. membership test, union, intersection, and (symmetric) difference.
2023-03-30T17:27:26+09:00 misc/py-shell-gpt Command-line productivity tool powered by ChatGPT
A command-line productivity tool powered by OpenAI's ChatGPT
(GPT-3.5). As developers, we can leverage ChatGPT capabilities to
generate shell commands, code snippets, comments, and documentation,
among other things. Forget about cheat sheets and notes, with this
tool you can get accurate answers right in your terminal, and you'll
probably find yourself reducing your daily Google searches, saving you
valuable time and effort.
2023-03-30T07:21:20+00:00 graphics/qview Practical and minimal image viewer
Qt image viewer designed with minimalism and usability in mind.
2023-03-29T13:54:23+02:00 print/ghostscript10 PostScript and PDF interpreter
Ghostscript is an interpreter for PostScript and Portable Document
Format (PDF) files. It allows you to manipulate such files and to
convert them to various printer, image and other formats.
2023-03-29T14:36:55+03:00 security/pam_howdy PAM module for Howdy Face Recognition
Howdy PAM is an authentication tool that allows you to unlock your desktop
session using your webcam. It uses facial recognition to authenticate and
unlock the session. This package provides PAM module for Howdy.
2023-03-28T17:09:16-07:00 devel/xeus-zmq ZeroMQ-based middleware for xeus
xeus-zmq provides various implementations of the xserver API from xeus, based
on the ZeroMQ library. These implementations all conform to the Jupyter Kernel
Protocol specification.
2023-03-28T07:44:12-07:00 devel/py-jupyter-kernel-test Tool for testing Jupyter kernels
jupyter_kernel_test is a tool for testing Jupyter kernels. It tests kernels
for successful code execution and conformance with the Jupyter Messaging
Protocol (currently 5.0).
2023-03-28T15:27:00+09:00 devel/py-setuptools_git_ls_files Python setuptools plugin to list all files tracked by git
setuptools_git_ls_files is a plugin for setuptools that finds all git tracked
files, including submodules.
2023-03-27T08:02:03-07:00 devel/py-treelib Python 2/3 implementation of tree structure
Treelib implements the tree structure in Python.

Tree is an important data structure in computer science. Examples are shown in
ML algorithm designs such as random forest tree and software engineering such
as file system index. treelib is created to provide an efficient implementation
of tree data structure in Python.
2023-03-27T08:02:03-07:00 sysutils/rtx Runtime Executor (asdf rust clone)
rtx is a polyglot runtime manager (asdf rust clone).

Features:
* asdf-compatible - rtx is compatible with asdf plugins and .tool-versions
files. It can be used as a drop-in replacement.
* Polyglot - compatible with any language, so no more figuring out how nvm,
nodenv, pyenv, etc work individually-just use 1 tool.
* Fast - rtx is written in Rust and is very fast. 20x-200x faster than asdf.
* No shims - shims cause problems, they break which, and add overhead. By
default, rtx does not use them-however you can if you want to.
* Fuzzy matching and aliases - It's enough to just say you want "v18" of node,
or the "lts" version. rtx will figure out the right version without you
needing to specify an exact version.
* Arbitrary env vars - Set custom env vars when in a project directory like
NODE_ENV=production or AWS_PROFILE=staging.
2023-03-27T20:24:25+01:00 devel/py-gitlab-webhook-handler Webhook Handler for GitLab
Webhook Handler for GitLab written in Python with Flask deployed as WSGI
application.
2023-03-27T08:02:03-07:00 sysutils/tuckr Super-powered replacement for GNU Stow
Tuckr is a dotfile manager inspired by Stow and Git. Tuckr aims to make dotfile
management less painful. It follows the same model as Stow, symlinking files
onto $HOME. It works on all the major OSes (Linux, Windows, BSDs and MacOS).

Tuckr aims to bring the simplicity of Stow to a dotfile manager with a very
small learning curve. To achieve that goal Tuckr tries to only cover what is
directly needed to manage dotfiles and nothing else. We won't wrap git, rm, cp
or reimplement the functionality that are perfeclty covered by other utilities
in the system unless it greatly impacts usability.
2023-03-27T00:45:29-04:00 devel/py-gpep517 Python package builder and installer for non-pip-centric world
gpep517 is a minimal tool to aid building wheels for Python packages
through PEP 517-compliant build systems and installing them. The
tool originated from Gentoo with its primary goals being absolutely
minimal dependency footprint to ease clean bootstrap without bundling
dependencies, and clean separation of functions to aid external
package managers. It is the tool of choice for a world that does
not revolve around pip and venvs.
2023-03-26T18:04:18+03:00 security/rubygem-doorkeeper562 OAuth2 provider for Rails and Grape
Doorkeeper is a Ruby gem that makes it easy to introduce OAuth 2
provider functionality to a Rails or Grape application.
2023-03-25T19:11:58+01:00 sysutils/blisp Utility and library for flashing Bouffalo RISC-V MCUs
Utility and library for flashing Bouffalo RISC-V MCUs such as upgrading
firmware on Pinecil V2 open source soldering iron
2023-03-23T10:31:25-03:00 x11/wmenu Efficient dynamic menu for Wayland
wmenu is an efficient dynamic menu for Sway and wlroots based Wayland
compositors. It provides a Wayland-native dmenu replacement which
maintains the look and feel of dmenu.
2023-03-24T10:57:23+00:00 misc/py-icoextract Extract icons from Windows EXE and DLL files
icoextract is an icon extractor for Windows PE files (.exe/.dll),
written in Python. It also includes a thumbnailer script
(exe-thumbnailer) for Linux desktops.

This project is inspired by extract-icon-py, icoutils,
and others.

icoextract aims to be:

Lightweight
Portable (cross-platform)
Fast on large files
2023-03-23T15:50:43+01:00 misc/wthrr Weather companion for the terminal
wthrr lives in your terminal and her passion is meteorology.

If you spend time in the TUI, you'll have a little companion nearby who knows
about the weather.
2023-03-22T02:36:04+08:00 www/rubygem-rack-session Session implementation for Rack
Rack::Session is a session management implementation for Rack.
2023-03-22T02:36:01+08:00 security/rubygem-rack-oauth21 OAuth 2.0 Server & Client Library
OAuth 2.0 Server & Client Library.
Both Bearer and MAC token type are supported.
2023-03-22T02:35:58+08:00 net/rubygem-google-cloud-resource_manager Official library for Google Cloud Resource Manager
Google Cloud Resource Manager enables you to programmatically manage container
resources such as Organizations and Projects, that allow you to group and
hierarchically organize other Cloud Platform resources. This hierarchical
organization lets you easily manage common aspects of your resources such as
access control and configuration settings.
2023-03-22T02:35:53+08:00 devel/rubygem-redlock1 Distributed lock using Redis written in Ruby
Redlock provides a ruby distributed lock using redis.

Distributed locks are a very useful primitive in many environments where
different processes require to operate with shared resources in a mutually
exclusive way.

There are a number of libraries and blog posts describing how to implement a DLM
(Distributed Lock Manager) with Redis, but every library uses a different
approach, and many use a simple approach with lower guarantees compared to what
can be achieved with slightly more complex designs.

This is an implementation of a proposed distributed lock algorithm with Redis.
It started as a fork from antirez implementation.
2023-03-22T02:35:52+08:00 devel/rubygem-google-iam-credentials-v1 Ruby Client for the IAM Service Account Credentials V1 API
The Service Account Credentials API creates short-lived credentials for Identity
and Access Management (IAM) service accounts. You can also use this API to sign
JSON Web Tokens (JWTs), as well as blobs of binary data that contain other types
of tokens.
2023-03-22T02:35:51+08:00 devel/rubygem-google-iam-credentials Ruby Client for the IAM Policy API
This is an add-on interface used by some Google API clients to provide IAM
policy calls.
2023-03-22T02:35:50+08:00 devel/rubygem-google-apis-sheets_v4 Simple REST client for Google Sheets API V4
This is the simple REST client for Google Sheets API V4. Simple REST clients are
Ruby client libraries that provide access to Google services via their HTTP REST
API endpoints. These libraries are generated and updated automatically based on
the discovery documents published by the service, and they handle most concerns
such as authentication, pagination, retry, timeouts, and logging. You can use
this client to access the Google Sheets API, but note that some services may
provide a separate modern client that is easier to use.
2023-03-22T02:35:49+08:00 devel/rubygem-google-apis-iam_v2beta Simple REST client for Identity and Access Management (IAM) API V2beta
This is the simple REST client for Identity and Access Management (IAM) API
V2beta. Simple REST clients are Ruby client libraries that provide access to
Google services via their HTTP REST API endpoints. These libraries are generated
and updated automatically based on the discovery documents published by the
service, and they handle most concerns such as authentication, pagination,
retry, timeouts, and logging. You can use this client to access the Identity and
Access Management (IAM) API, but note that some services may provide a separate
modern client that is easier to use.
2023-03-22T02:35:47+08:00 devel/rubygem-google-apis-iam_v2 Simple REST client for Identity and Access Management (IAM) API V2
This is the simple REST client for Identity and Access Management (IAM) API V2.
Simple REST clients are Ruby client libraries that provide access to Google
services via their HTTP REST API endpoints. These libraries are generated and
updated automatically based on the discovery documents published by the service,
and they handle most concerns such as authentication, pagination, retry,
timeouts, and logging. You can use this client to access the Identity and Access
Management (IAM) API, but note that some services may provide a separate modern
client that is easier to use.
2023-03-22T02:35:46+08:00 devel/rubygem-google-apis-drive_v3 Simple REST client for Drive API V3
This is the simple REST client for Drive API V3. Simple REST clients are Ruby
client libraries that provide access to Google services via their HTTP REST API
endpoints. These libraries are generated and updated automatically based on the
discovery documents published by the service, and they handle most concerns such
as authentication, pagination, retry, timeouts, and logging. You can use this
client to access the Drive API, but note that some services may provide a
separate modern client that is easier to use.
2023-03-22T02:35:45+08:00 devel/rubygem-google-apis-cloudresourcemanager_v3 Simple REST client for Cloud Resource Manager API V3
This is the simple REST client for Cloud Resource Manager API V3. Simple REST
clients are Ruby client libraries that provide access to Google services via
their HTTP REST API endpoints. These libraries are generated and updated
automatically based on the discovery documents published by the service, and
they handle most concerns such as authentication, pagination, retry, timeouts,
and logging. You can use this client to access the Cloud Resource Manager API,
but note that some services may provide a separate modern client that is easier
to use.
2023-03-22T02:35:44+08:00 devel/rubygem-google-apis-cloudresourcemanager_v2 Simple REST client for Cloud Resource Manager API V2
This is the simple REST client for Cloud Resource Manager API V2. Simple REST
clients are Ruby client libraries that provide access to Google services via
their HTTP REST API endpoints. These libraries are generated and updated
automatically based on the discovery documents published by the service, and
they handle most concerns such as authentication, pagination, retry, timeouts,
and logging. You can use this client to access the Cloud Resource Manager API,
but note that some services may provide a separate modern client that is easier
to use.
2023-03-22T02:35:43+08:00 devel/rubygem-aws-sdk-tnb Official AWS Ruby gem for AWS Telco Network Builder
Official AWS Ruby gem for AWS Telco Network Builder.
2023-03-22T02:35:42+08:00 devel/rubygem-aws-sdk-cloudtraildata Official AWS Ruby gem for AWS CloudTrail Data Service
Official AWS Ruby gem for AWS CloudTrail Data Service.
2023-03-22T02:35:40+08:00 www/py-wagtail-transfer Content transfer for Wagtail
Wagtail Transfer is an extension for Wagtail allowing content to be transferred
between multiple instances of a Wagtail project.
2023-03-22T02:35:38+08:00 www/py-wagtail-localize Translation plugin for Wagtail CMS
Wagtail Localize is a translation plugin for the Wagtail CMS. It allows pages or
snippets to be translated within Wagtail's admin interface. It also provides
integrations with external translations services such as Pontoon or DeepL, and
importing/exporting translations with PO files.
2023-03-22T02:35:35+08:00 www/py-wagtail-factories Factory boy classes for wagtail
Factory boy classes for Wagtail CMS
2023-03-22T02:35:32+08:00 www/py-wagtail-bakery Set of helpers for baking your Django Wagtail site out as flat files
Wagtail-bakery is built on top of Django bakery. Please read their documentation
for detailed configuration and how to build default Django flat files. Yes.
Wagtail-bakery is not limited to build Wagtail pages specifically, mixed content
is possible!
2023-03-22T02:35:29+08:00 www/py-wagtail-airtable Sync data between Wagtail and Airtable
Wagtail/Airtable is an extension for Wagtail allowing content to be transferred
between Airtable sheets and your Wagtail/Django models.
2023-03-22T02:35:26+08:00 www/py-wagtail-2fa Two factor authentication for Wagtail
This Django app adds two factor authentication to Wagtail. Behind the scenes it
use django-otp which supports Time-based One-Time Passwords (TOTP). This allows
you to use various apps like Authy, Google Authenticator, or 1Password.
2023-03-22T02:35:23+08:00 net/py-uri-template RFC 6570 URI Template Processor
uri_template implements URI Template expansion in strict adherence to RFC 6570,
but adds a few extensions.
2023-03-22T02:35:18+08:00 devel/py-ypy-websocket WebSocket connector for Ypy
ypy-websocket is an async WebSocket connector for Ypy.
2023-03-22T02:35:17+08:00 devel/py-y-py Python bindings for the Y-CRDT built from yrs (Rust)
Ypy is a Python binding for Y-CRDT. It provides distributed data types that
enable real-time collaboration between devices. Ypy can sync data with any other
platform that has a Y-CRDT binding, allowing for seamless cross-domain
communication. The library is a thin wrapper around Yrs, taking advantage of the
safety and performance of Rust.
2023-03-22T02:35:16+08:00 devel/py-types-setuptools Typing stubs for setuptools
This is a PEP 561 type stub package for the setuptools package. It can be used
by type-checking tools like mypy, pyright, pytype, PyCharm, etc. to check code
that uses setuptools.
2023-03-22T02:35:15+08:00 devel/py-rfc3986-validator Pure python rfc3986 validator
A pure python RFC3986 validator
2023-03-22T02:35:14+08:00 devel/py-jupyter-ydoc Document structures for collaborative editing using Ypy
jupyter_ydoc provides Ypy-based data structures for various documents used in
the Jupyter ecosystem. Built-in documents include:
- YBlob: a generic immutable binary document.
- YUnicode: a generic UTF8-encoded text document (YFile is an alias to
YUnicode).
- YNotebook: a Jupyter notebook document.
2023-03-22T02:35:13+08:00 devel/py-jupyter-server-ydoc Jupyter Server Extension Providing Y Documents
Jupyter Server YDoc is a Jupyter Server Extension providing support for Y
documents.
2023-03-22T02:35:11+08:00 devel/py-jupyter-server-fileid Jupyter Server extension for File ID service
Jupyter Server extension providing an implementation of the File ID service
2023-03-22T02:35:10+08:00 devel/py-jupyter-events Jupyter Event System library
Jupyter Events enables Jupyter Python Applications (e.g. Jupyter Server,
JupyterLab Server, JupyterHub, etc.) to emit events -- structured data
describing things happening inside the application. Other software (e.g. client
applications like JupyterLab) can listen and respond to these events.
2023-03-22T02:35:09+08:00 devel/py-isoduration Operations with ISO 8601 durations
ISO 8601 is most commonly known as a way to exchange datetimes in textual
format. A lesser known aspect of the standard is the representation of
durations. They have a shape similar to this:
P3Y6M4DT12H30M5S
This string represents a duration of 3 years, 6 months, 4 days, 12 hours, 30
minutes, and 5 seconds.

The state of the art of ISO 8601 duration handling in Python is more or less
limited to what's offered by isodate. What we are trying to achieve here is to
address the shortcomings of isodate (as described in their own Limitations
section), and a few of our own annoyances with their interface, such as the lack
of uniformity in their handling of types, and the use of regular expressions for
parsing.
2023-03-22T02:35:08+08:00 devel/py-hatch-semver Hatch plugin for semver versioning scheme
hatch-semver is a plugin for hatch to support semantic versioning. Hatch-semver
relies on python-semver for all the versioning logic.
2023-03-22T02:35:07+08:00 devel/py-hatch-jupyter-builder Hatch plugin to help build Jupyter packages
hatch-jupyter-builder provides a build hook plugin for Hatch that adds a build
step for use with Jupyter packages.
2023-03-22T02:35:05+08:00 devel/py-glom Declarative object transformer and formatter
Real applications have real data, and real data nests. Objects inside of objects
inside of lists of objects.

glom is a new and powerful way to handle real-world data, featuring:
- Path-based access for nested data structures
- Readable, meaningful error messages
- Declarative data transformation, using lightweight, Pythonic specifications
- Built-in data exploration and debugging features

All of that and more, available as a fully-documented, pure-Python package.
2023-03-22T02:35:04+08:00 devel/py-face Command-line application framework (and CLI parser)
face is a Pythonic microframework for building command-line applications:
- First-class subcommand support
- Powerful middleware architecture
- Separate Parser layer
- Built-in flagfile support
- Handy testing utilities
- Themeable help display
2023-03-22T02:35:03+08:00 devel/py-click-option-group Option groups missing in Click
click-option-group is a Click-extension package that adds option groups missing
in Click.

Click is a package for creating powerful and beautiful command line interfaces
(CLI) in Python, but it has no the functionality for creating option groups.

Option groups are convenient mechanism for logical structuring CLI, also it
allows you to set the specific behavior and set the relationship among grouped
options (mutually exclusive options for example). Moreover, argparse stdlib
package contains this functionality out of the box.

At the same time, many Click users need this functionality. You can read
interesting discussions about it in the issues 257, 373, 509 and 1137.

The aim of this package is to provide group options with extensible
functionality using canonical and clean API (Click-like API as far as possible).
2023-03-22T02:35:02+08:00 devel/py-boltons Functionality that should be in the standard library
Boltons is a set of over 230 BSD-licensed, pure-Python utilities in the same
spirit as -- and yet conspicuously missing from -- the standard library,
including:
- Atomic file saving, bolted on with fileutils
- A highly-optimized OrderedMultiDict, in dictutils
- Two types of PriorityQueue, in queueutils
- Chunked and windowed iteration, in iterutils
- Recursive data structure iteration and merging, with iterutils.remap
- Exponential backoff functionality, including jitter, through iterutils.backoff
- A full-featured TracebackInfo type, for representing stack traces, in tbutils
2023-03-22T02:35:01+08:00 devel/py-airtable-python-wrapper Python API Wrapper for the Airtable API
Python Client for the Airtable API
2023-03-22T02:34:59+08:00 databases/py-sqlalchemy20 Python SQL toolkit and Object Relational Mapper 2.0.x
The Python SQL Toolkit and Object Relational Mapper

SQLAlchemy is the Python SQL toolkit and Object Relational Mapper that gives
application developers the full power and flexibility of SQL.

It provides a full suite of well known enterprise-level persistence patterns,
designed for efficient and high-performing database access, adapted into a
simple and Pythonic domain language.
2023-03-21T09:45:29+09:00 textproc/py-dialect Translation app for GNOME
A translation app for GNOME.

Features:
- Translation based on Google Translate
- Translation based on the LibreTranslate API, allowing you to use any
public instance
- Translation history
- Automatic language detection
- Text to speech
- Clipboard buttons
2023-03-19T17:33:19-10:00 security/pam_rssh Remote sudo authenticated via ssh-agent
This PAM module provides ssh-agent based authentication. The primary design
goal is to avoid typing password when you sudo on remote servers. Instead, you
can simply touch your hardware security key (e.g. Yubikey/Canokey) to fulfill
user verification. The process is done by forwarding the remote authentication
request to client-side ssh-agent as a signature request.
2023-03-18T21:06:19+08:00 textproc/fcitx5-gtk-common Fcitx support for GTK+ (common files)
2023-03-17T18:58:47+00:00 multimedia/ffmpeg4 Realtime audio/video encoder/converter and streaming server (legacy 4.* series)
FFmpeg is a complete, cross-platform solution to record, convert and stream
audio and video. It includes libavcodec - the leading audio/video codec
library.
2023-03-16T17:57:09-05:00 www/dolibarr16 Modern software package to manage your company or foundation
Dolibarr ERP & CRM is a modern software package to manage your organization's
activity (contacts, suppliers, invoices, orders, stocks, agenda)

It's an Open Source Software (written in PHP language) designed for small,
medium or large companies, foundations and freelances.

You can freely use, study, modify or distribute it according to its Free
Software licence.

You can use it as a standalone application or as a web application to be able
to access it from the Internet or a LAN.
2023-03-16T12:08:12+01:00 devel/rubygem-octicons Package to distribute GitHub's octicons svg
Your project. GitHub's icons.

Octicons are a set of SVG icons built by GitHub for GitHub. This is a Ruby
gem with a Ruby API. For more options see and in particular the rails helper
see:
https://octicons.github.com/
2023-03-16T11:34:54+02:00 textproc/rubygem-psych3 YAML parser and emitter
Psych is a YAML parser and emitter. Psych leverages libyaml for its YAML parsing
and emitting capabilities. In addition to wrapping libyaml, Psych also knows how
to serialize and de-serialize most Ruby objects to and from the YAML format.
2023-03-16T06:55:47+01:00 devel/py-hatch-requirements-txt Hatchling plugin to read project dependencies from requirements.txt
Hatchling plugin to read project dependencies from "requirements.txt" and there
is support for defining groups of optional dependencies (also known as
"features") as well.
2023-03-16T06:54:32+01:00 devel/py-hatch-nodejs-version Hatch plugin for versioning from a package.json file
This package provides two Hatch plugins:

* version source plugin that reads/writes the package version from the version
field of the Node.js package.json file.

* metadata hook plugin that reads PEP 621 metadata from the Node.js
package.json file.
2023-03-16T05:40:54+00:00 editors/uhex Simple and fast console hexadecimal editor
uHex is small and fast multiplatform hexadecimal editor with support
for large files (up to 2 GB) while using minimal amounts of memory.
2023-03-16T04:07:34+00:00 editors/mickey Simple hexadecimal editor written in FLTK
Mickey is a hexadecimal/ASCII file viewer and editor that runs on all
major operating systems thanks to FLTK. It supports various integer
and floating-point data types, and allows to work with multiple files
simultaneously via well-known tabbed interface. Unfortunately, there
is no support for editing of very large files yet.
2023-03-16T03:29:34+00:00 editors/bingrok Binary data editor for reverse engineering
BinGrok is a binary/hexadecimal editor created specifically with
the goal of reverse-engineering proprietary data formats in mind.
It allows for creation of C-struct-like "views" of your data for
better visualization of the parts that you have deciphered.
2023-03-15T11:32:24-04:00 www/unitc Command-line management tool for NGINX Unit
The unitc tool provides a command-line interface as a wrapper for curl(1)
for daily configuration and management of NGINX Unit instances. It aims
to minimize typing effort and shield the users from exotic curl(1) options.
2023-03-15T10:39:38+00:00 editors/bined Binary/hexadecimal editor written in Java
Editor for binary data (hexadecimal viewer/editor) written in Java.

- Visualize data as hexadecimal codes and text representation
- Insert and overwrite editing modes
- Support for selection and clipboard actions
- Support for showing unprintable/whitespace characters
- Support for Unicode, UTF-8, and other character sets
- Support for charset/encoding selection, undo/redo
- Codes can be also binary, octal, or decimal
- Searching for text/hexadecimal code with match highlighting
- Support for huge files (only changes are stored in memory)
2023-03-15T03:17:16-07:00 misc/flashlight Standalone C++ library for machine learning
Flashlight is a fast, flexible machine learning library written entirely in C++
from the Facebook AI Research and the creators of Torch, TensorFlow, Eigen and
Deep Speech.

Its core features include:
* Total internal modifiability including internal APIs for tensor computation.
* A small footprint, with the core clocking in at under 10 MB and 20k lines
of C++.
* High-performance defaults featuring just-in-time kernel compilation with
modern C++ via the ArrayFire tensor library.
* An emphasis on efficiency and scale.
2023-03-15T03:08:57-07:00 math/onednn252 Intel(R) Math Kernel Library for Deep Neural Networks
Intel(R) Math Kernel Library for Deep Neural Networks (Intel(R) MKL-DNN) is an
open source performance library for deep learning applications. The library
accelerates deep learning applications and framework on Intel(R) architecture.
Intel(R) MKL-DNN contains vectorized and threaded building blocks which you can
use to implement deep neural networks (DNN) with C and C++ interfaces.

DNN functionality optimized for Intel architecture is also included in Intel(R)
Math Kernel Library (Intel(R) MKL). API in this implementation is not compatible
with Intel MKL-DNN and does not include certain new and experimental features.
2023-03-14T19:26:39-07:00 devel/cli Library for interactive command line interfaces in modern C++
cli is a cross-platform header only C++14 library for interactive command line
interfaces (Cisco style).
2023-03-14T18:24:08+00:00 security/openssl31 TLSv1.3 capable SSL and crypto library
The OpenSSL Project is a collaborative effort to develop a robust,
commercial-grade, full-featured, and Open Source toolkit implementing
the Secure Sockets Layer (SSL v3) and Transport Layer Security (TLS v1,
v1.1, v1.2, v1.3) protocols with full-strength cryptography world-wide.
The project is managed by a worldwide community of volunteers that use
the Internet to communicate, plan, and develop the OpenSSL tookit
and its related documentation.

OpenSSL is based on the excellent SSLeay library developed by Eric
A. Young and Tim J. Hudson. The OpenSSL toolkit is licensed under
an Apache-style licence, which basically means that you are free
to get and use it for commercial and non-commercial purposes subject
to some simple license conditions.
2023-03-14T18:19:53+00:00 security/openssl30 TLSv1.3 capable SSL and crypto library
The OpenSSL Project is a collaborative effort to develop a robust,
commercial-grade, full-featured, and Open Source toolkit implementing
the Secure Sockets Layer (SSL v3) and Transport Layer Security (TLS v1,
v1.1, v1.2, v1.3) protocols with full-strength cryptography world-wide.
The project is managed by a worldwide community of volunteers that use
the Internet to communicate, plan, and develop the OpenSSL tookit
and its related documentation.

OpenSSL is based on the excellent SSLeay library developed by Eric
A. Young and Tim J. Hudson. The OpenSSL toolkit is licensed under
an Apache-style licence, which basically means that you are free
to get and use it for commercial and non-commercial purposes subject
to some simple license conditions.
2023-03-12T18:10:37-06:00 editors/neovim-gtk Neovim client library and GTK4 GUI
GTK ui for neovim

GTK ui for neovim written in rust using gtk-rs bindings. With ligatures
support. This project began as a fork of @daa84's neovim-gtk.
2023-03-09T07:09:07-04:00 editors/vis Vi-like editor based on Plan 9's structural regular expressions
Vis aims to be a modern, legacy-free, simple yet efficient editor,
combining the strengths of both vi(m) and sam.

It extends vi's modal editing with built-in support for multiple
cursors/selections and combines it with sam's structural regular
expression based command language.

Efficient syntax highlighting is provided using Parsing Expression
Grammars, which can be conveniently expressed using Lua in the form
of LPeg.

The editor core is written in a reasonable amount of clean, modern
and legacy-free C code, enabling it to run in resource-constrained
environments. There is also a Lua API for in-process extensions.

Vis strives to be simple and focuses on its core task: efficient
text management. Clipboard and digraph handling as well as a fuzzy
file open dialog are all provided by independent utilities.
2023-03-13T22:04:41+01:00 devel/ccache4 Tool to minimize the compile time of C/C++ programs
ccache is a compiler cache. It acts as a caching pre-processor to C/C++
compilers, using the -E compiler switch and a hash to detect when a
compilation can be satisfied from cache. This often results in a 5 to 10
times speedup in common compilations.
2023-03-13T10:34:06+01:00 databases/libmongocrypt MongoDB companion C library for client side encryption in drivers
MongoDB companion C library for client side encryption in drivers
2023-03-12T10:35:07+01:00 security/libomemo-c Implementation of the ratcheting forward secrecy protocol
This is a fork of libsignal-protocol-c, an implementation of Signal's
ratcheting forward secrecy protocol that works in synchronous and asynchronous
messaging. The fork adds support for OMEMO as defined in XEP-0384 versions
0.3.0 and later.

* OMEMO version 0.3.0 uses the original libsignal-protocol-c implementation
with its protocol versions 2 and 3.

* OMEMO version 0.4.0+ is implemented using a new protocol version 4
internally. In comparison with protocol version 3, it changes:
* HKDF info strings
* Protocol buffer encoding
* Signature scheme (uses XEd25519 instead of custom "Curve25519 signatures")
* Specification-compliant double ratchet
* Support for Ed25519 public keys
* Various serializations
* Removes unused functionality
2023-03-11T14:42:53-08:00 net/aws-ec2-imdsv2-get Reads data from EC2 IMDS with v2 protocol
Tool for reading data from the EC2 Instance Metadata Service (IMDS),
supporting both the original (v1) protocol and the newer (v2) protocol.
2023-03-11T13:16:00+01:00 www/squid-langpack Language-specific error documents for Squid web cache
The pre-translated error pages displayed by Squid.

As squid does not contain pre-translated error pages,
provide it as a separate package.
2023-03-10T15:48:47+01:00 x11-wm/bspwm-devel Tiling window manager based on binary space partitioning
bspwm is a tiling window manager that represents windows as the leaves
of a full binary tree. It is controlled and configured via bspc.
2023-03-09T15:46:28-04:00 sysutils/appjail Simple and easy-to-use tool for creating portable jails
AppJail is an open source framework entirely written in sh(1) and
C to create isolated, portable and easy to deploy environments using
FreeBSD jails that behaves like an application.
2023-03-11T03:56:24+00:00 x11-wm/swayfx Sway, but with eye candy!
Sway is an incredible window manager, and certainly one of the most
well established wayland window managers. However, it is restricted to
only include the functionality that existed in i3. This fork ditches
the simple wlr_renderer, and replaces it with our fx_renderer, capable
of rendering with fancy GLES2 effects. This, along with a couple of
minor changes, expands sway's featureset to include the following:

+ Blur
+ Anti-aliased rounded corners, borders, and titlebars
+ Shadows
+ Dim unfocused windows
+ Per application saturation control: Allows the user to set the
saturation (Digital Vibrance) for specific applications. Great for
some FPS games!
+ Scratchpad treated as minimize: Allows docks, or panels with a
taskbar, to correctly interpret minimize / unminimize requests
2023-03-08T23:48:14-05:00 devel/meson-python Meson Python build backend (PEP-517)
Python build backend (PEP-517) for Meson projects.

It enables Python package authors to use Meson as the build backend
for their packages.
2023-03-08T18:04:47+03:00 security/linux-c7-ca-certificates Mozilla CA root certificate bundle (Linux CentOS ${LINUX_DIST_VER})
Root certificates from certificate authorities included in the Mozilla
NSS library and thus in Firefox and Thunderbird.
2023-03-08T11:18:53+01:00 net-mgmt/zabbix64-server Enterprise-class open source distributed monitoring (${PKGNAMESUFFIX:S/^-//})
Zabbix is an enterprise-class open source distributed monitoring solution.

Zabbix is software that monitors numerous parameters of a network and the
health and integrity of servers. Zabbix uses a flexible notification
mechanism that allows users to configure e-mail based alerts for virtually
any event. This allows a fast reaction to server problems. Zabbix offers
excellent reporting and data visualisation features based on the stored
data. This makes Zabbix ideal for capacity planning.
2023-03-08T11:18:53+01:00 net-mgmt/zabbix64-proxy
2023-03-08T11:18:53+01:00 net-mgmt/zabbix64-java
2023-03-08T11:18:53+01:00 net-mgmt/zabbix64-frontend
2023-03-08T11:18:53+01:00 net-mgmt/zabbix64-agent
2023-03-07T10:07:21+01:00 devel/godot35-tools Game integrated development environment
2023-03-07T10:26:30+01:00 devel/godot35 Game runtime engine - LTS v3.5
Godot is a multi-platform 2D and 3D game engine.

Easily deploy your game on IOS, Android, OSX, Linux, Steam or Windows.

This is a runtime only port of godot. For the IDE to create games
use devel/godot-tools.
2023-03-04T15:38:06-05:00 textproc/code-minimap High performance code minimap render
A high performance code minimap render. This tool is for generating text
minimaps at speed. You can use it to implement IDE-like minimap plugin for a
terminal text editor, minimap.vim for example.
2023-03-04T15:09:18+01:00 print/sioyek PDF viewer with focus on technical books and research papers
Sioyek is a PDF viewer with a focus on technical books and research papers.

Searchable
Quickly search your previously opened documents, table of
contents, bookmarks, and highlights. Sioyek can even generate
the table of contents if the document doesn't have one!

Smart Jump
You can preview or jump to references (e.g. bibliography, figures,
equations, etc.) even when the document doesn't have links. You
can also search references in google scholar with one click!

Portals
You can create portals from parts of documents to other parts
displayed in a second window. So when you are reading a paragraph
that is talking about a figure, table, algorithm, theorem, etc.
you don't have to keep jumping between the two locations.

Marks and Bookmarks
Mark locations with one-character symbols and then quickly jump
back to them. You can also create bookmarks which are like marks,
but use a descriptive text instead of a symbol and can be searched.

Keyboard Focused
While sioyek fully supports many mouse actions, it is still
possible to use sioyek only using a keyboard. This includes
functionality such as text selection too!

Synctex
Sioyek autoreloads the document so you can preview the changes
as you edit the latex file. You can also jump between the
corresponding locations in PDF and latex files with one click.

Other features include configurability, extensibility with external
commands and scripts, text highlighting, a discoverable command palette,
and a visual ruler highlighting the current line.
2023-03-06T22:12:47+03:00 net/libndp Neighbor discovery library
This package contains a library which provides a wrapper for IPv6 Neighbor
Discovery Protocol. It also provides a tool named ndptool for sending and
receiving NDP messages.
2023-03-06T19:01:37+08:00 math/py-contourpy Python library for calculating contours of 2D quadrilateral grids
ContourPy is a Python library for calculating contours of 2D quadrilateral
grids. It is written in C++11 and wrapped using pybind11.
2023-03-05T11:41:00-10:00 security/pam_u2f Pluggable Authentication Module for U2F and FIDO2
This module implements PAM over U2F and FIDO2, providing an easy way to
integrate the YubiKey (or other U2F/FIDO2 compliant authenticators) into your
existing infrastructure.
2023-03-04T22:04:18+00:00 devel/py-flake8-future-annotations Verifies python 3.7+ files use from __future__ import annotations
Verifies python 3.7+ files use from __future__ import annotations if a
type is used in the module that can be rewritten using PEP 563.

Pairs well with pyupgrade with the --py37-plus flag or higher, since
pyupgrade only replaces type annotations with the PEP 563 rules if
from __future__ import annotations is present.
2023-03-04T15:33:36+03:00 x11/budgie Meta-port for the Budgie Desktop Environment
Budgie Desktop Environment.

This is a "meta-port", this package depends on other Budgie packages.
2023-03-04T15:33:36+03:00 x11/budgie-screensaver Budgie screen saver and locker
Budgie Screensaver is a fork of gnome-screensaver intended for use with
Budgie desktop and is similar in purpose of other screensavers.

2023-03-04T15:33:36+03:00 x11/budgie-desktop Modern and familiar desktop environment
The Budgie Desktop is a feature-rich, modern desktop designed
to keep out the way of the user.
It consists of a number of components to provide a more complete
desktop experience:

* budgie menu
* raven
* notifications
* several popup windows (find applications, session, polkit agent)
2023-03-04T15:33:36+03:00 x11-themes/tela-icon-theme Flat icon theme
This package contains a flat colorful design icon theme.
2023-03-04T15:33:36+03:00 x11-themes/budgie-backgrounds Set of backgrounds for Budgie desktop
Budgie backgrounds is the default set of background images for the Budgie
desktop.
2023-03-04T15:33:36+03:00 sysutils/budgie-control-center Control center for the Budgie desktop
Budgie Control Center is a fork of GNOME Settings / GNOME Control Center
with the intent of providing a simplified list of settings that are
applicable to the Budgie 10 series, along with any small quality-of-life
settings.
2023-03-04T15:33:36+03:00 deskutils/budgie-trash-applet Trash applet for the Budgie desktop
Manage items in your trash bin right from the Budgie panel. View,
delete, or restore trashed files and folders without having to open
your file manager.
2023-03-04T15:33:36+03:00 deskutils/budgie-desktop-view Budgie desktop icons application / implementation
Budgie Desktop View provides quick access to the content and
applications you consider most important. It is not designed
to replace your file manager or to perform typical file manager
actions.
2023-03-04T15:34:16+01:00 multimedia/mkvtoolnix-nox11 Tools to extract from/get info about/create Matroska media streams (no X11)
2023-03-04T18:37:21+08:00 astro/py-astroML Tools for machine learning and data mining in Astronomy
AstroML is a Python module for machine learning and data mining built on
numpy, scipy, scikit-learn, and matplotlib, and distributed under the BSD
license. It contains a growing library of statistical and machine learning
routines for analyzing astronomical data in python, loaders for several
open astronomical datasets, and a large suite of examples of analyzing and
visualizing astronomical datasets.
2023-03-04T01:39:14+01:00 misc/qt6ct Qt 6 configuration tool
This program allows users to configure Qt6 settings (theme, font, icons, etc.)
under DE/WM without Qt integration.
2023-03-04T11:31:40+08:00 misc/p5-OpenAI-API Perl interface to OpenAI API
OpenAI::API is a Perl module that provides an interface to the
OpenAI API, which allows you to generate text, translate languages,
summarize text, and perform other tasks using the language models
developed by OpenAI.
2023-02-21T22:17:02+01:00 multimedia/jellyfin Jellyfin Server Component with WebUI
Jellyfin is the volunteer-built media solution that
puts you in control of your media.
Stream to any device from your own server, with no strings attached.

Your media, your server, your way.
2023-03-02T08:04:19-08:00 cad/gdscpp C++ library to create and read GDSII file
GDScpp is a C++ library that make GDS file manipulation easier.

Features:
* Convert GDS data to ASCII.
* Easily create GDS files.
* Import GDS files.
* Extract the root GDS structures.
* Create a hierarchy diagram of all the GDS structure dependencies.
* Direct importing of GDS files with redundancy checking.
* Create bounding box of all the GDS structures.
2023-03-02T14:55:02+00:00 devel/py-tendo Basic functionality that is not provided by Python
Tendo is a python module that adds basic functionality that is not provided by
Python. Read the documentation for more info.

* file-based singleton capability
* transparent Unicode support for text file operations (BOM detection)
* console logging coloring
* enable you to use symlinks under windows
* python tee implementation for executing external programs and redirecting
their output to both console/file
* improved execfile
2023-02-27T18:20:23+03:00 net-im/webinar Platform for organizing online conferences
Webinar is a Russian cloud-based and on-premise solution for organizing online
conferences and webinars.
2023-02-27T17:29:07-08:00 misc/py-openai Python client library for the OpenAI API
The OpenAI Python library provides convenient access to the OpenAI API from
applications written in the Python language.
2023-02-27T17:23:18-08:00 misc/py-wandb CLI and library for interacting with the Weights and Biases API
wandb helps to build better machine learning models faster. It allows to track
and visualize all the pieces of your machine learning pipeline, from datasets
to production machine learning models.
2023-01-22T20:12:03+01:00 sysutils/tmux-xpanes Ultimate terminal divider powered by tmux
Ultimate terminal divider powered by tmux

- Split tmux window into multiple panes
- * Construct command lines & execute them on the panes
- Runnable from outside of tmux session
- Runnable from inside of tmux session
- Record operation log
- Flexible layout arrangement for panes
- * Select layout presets
- * Set columns or rows as you like
- Display pane title on each pane
- Generate command lines from standard input (Pipe mode)
2023-02-21T18:59:48+00:00 net/xapsd Apple push notifications daemon for dovecot
Apple push notification daemon for dovecot.

Together with dovecot-xaps-plugin, this will enable push email
for iOS devices that talk to your dovecot IMAP server.
2023-02-27T19:50:39+01:00 devel/libcdada Basic data structures in C as libstdc++ wrapper
Small library that offers basic data structures (list, set, map...)
in a pure C API for user-space applications. Key features:

- Easy to use, portable
- No "magic" MACROs, and no need to modify your data structures
(except, perhaps, for __attribute__((packed)))
- Stable and well-tested backend engine (libstdc++) for most of
the data structures
- Reasonable performance - comparable to libstdc++
2023-02-27T20:32:07+09:00 textproc/choose Human-friendly and fast alternative to cut and (sometimes) awk
This is choose, a human-friendly and fast alternative to cut and
(sometimes) awk.

Features
- terse field selection syntax similar to Python's list slices
- negative indexing from end of line
- optional start/end index
- zero-indexed
- reverse ranges
- aslightly faster than cut for sufficiently long inputs, much faster
than awk
- regular expression field separators using Rust's regex syntax
2023-02-27T09:33:44+02:00 devel/rubygem-google-apis-sqladmin_v1beta4_041 Simple REST client for Cloud SQL Admin API V1beta4
This is a simple client library for version V1beta4 of the Cloud SQL Admin API.
It provides:
- A client object that connects to the HTTP/JSON REST endpoint for the service.
- Ruby objects for data structures related to the service.
- Integration with the googleauth gem for authentication using OAuth, API keys,
and service accounts.
- Control of retry, pagination, and timeouts.

See also: https://github.com/googleapis/google-api-ruby-client
2023-02-27T09:33:44+02:00 devel/rubygem-google-apis-serviceusage_v1_041 Simple REST client for Cloud SQL Admin API V1beta4
This is a simple client library for version V1beta4 of the Cloud SQL Admin API.
It provides:
- A client object that connects to the HTTP/JSON REST endpoint for the service.
- Ruby objects for data structures related to the service.
- Integration with the googleauth gem for authentication using OAuth, API keys,
and service accounts.
- Control of retry, pagination, and timeouts.

See also: https://github.com/googleapis/google-api-ruby-client
2023-02-27T09:33:44+02:00 devel/rubygem-google-apis-serviceusage_v1 Simple REST client for Service Usage API V1
This is the simple REST client for Service Usage API V1. Simple REST clients are
Ruby client libraries that provide access to Google services via their HTTP REST
API endpoints. These libraries are generated and updated automatically based on
the discovery documents published by the service, and they handle most concerns
such as authentication, pagination, retry, timeouts, and logging. You can use
this client to access the Service Usage API, but note that some services may
provide a separate modern client that is easier to use.

See also: https://github.com/googleapis/google-api-ruby-client
2023-02-27T09:33:44+02:00 devel/rubygem-google-apis-iam_v1 Simple REST client for IAM API V1
This is the simple REST client for Identity and Access Management (IAM) API V1.
Simple REST clients are Ruby client libraries that provide access to Google
services via their HTTP REST API endpoints. These libraries are generated and
updated automatically based on the discovery documents published by the service,
and they handle most concerns such as authentication, pagination, retry, timeouts,
and logging. You can use this client to access the Identity and Access
Management (IAM) API, but note that some services may provide a separate modern
client that is easier to use.

See also: https://github.com/googleapis/google-api-ruby-client
2023-02-27T09:33:44+02:00 devel/rubygem-google-apis-container_v1beta1 Simple REST client for Kubernetes Engine API V1
This is the simple REST client for Kubernetes Engine API V1beta1. Simple REST
clients are Ruby client libraries that provide access to Google services via
their HTTP REST API endpoints. These libraries are generated and updated
automatically based on the discovery documents published by the service, and
they handle most concerns such as authentication, pagination, retry, timeouts,
and logging. You can use this client to access the Kubernetes Engine API, but
note that some services may provide a separate modern client that is easier to
use.

See also: https://github.com/googleapis/google-api-ruby-client
2023-02-27T09:33:44+02:00 devel/rubygem-google-apis-container_v1 Simple REST client for Kubernetes Engine API V1
This is the simple REST client for Kubernetes Engine API V1. Simple REST clients are
Ruby client libraries that provide access to Google services via their HTTP REST API
endpoints. These libraries are generated and updated automatically based on the
discovery documents published by the service, and they handle most concerns such as
authentication, pagination, retry, timeouts, and logging. You can use this client to
access the Kubernetes Engine API, but note that some services may provide a separate
modern client that is easier to use.


See also: https://github.com/googleapis/google-api-ruby-client
2023-02-27T09:33:44+02:00 devel/rubygem-google-apis-compute_v1_057 Simple REST client for Compute Engine API V1
This is a simple client library for version V1 of the Compute Engine API. It
provides:
- A client object that connects to the HTTP/JSON REST endpoint for the service.
- Ruby objects for data structures related to the service.
- Integration with the googleauth gem for authentication using OAuth, API keys,
and service accounts.
- Control of retry, pagination, and timeouts.

See also: https://github.com/googleapis/google-api-ruby-client
2023-02-27T09:33:44+02:00 devel/rubygem-google-apis-cloudresourcemanager_v1 Simple REST client for Cloud Resource Manager API V1
This is the simple REST client for Cloud Resource Manager API V1. Simple REST
clients are Ruby client libraries that provide access to Google services via
their HTTP REST API endpoints. These libraries are generated and updated
automatically based on the discovery documents published by the service, and
they handle most concerns such as authentication, pagination, retry, timeouts,
and logging. You can use this client to access the Cloud Resource Manager API,
but note that some services may provide a separate modern client that is
easier to use.

See also: https://github.com/googleapis/google-api-ruby-client
2023-02-27T09:33:44+02:00 devel/rubygem-google-apis-cloudbilling_v1 Simple REST client for Cloud Billing API V1
This is the simple REST client for Cloud Billing API V1. Simple REST clients are
Ruby client libraries that provide access to Google services via their HTTP REST
API endpoints. These libraries are generated and updated automatically based on
the discovery documents published by the service, and they handle most concerns
such as authentication, pagination, retry, timeouts, and logging. You can use
this client to access the Cloud Billing API, but note that some services may
provide a separate modern client that is easier to use.

See also: https://github.com/googleapis/google-api-ruby-client
2023-02-26T00:03:16-08:00 devel/zycore-c Support library with platform independent types, macros, etc for Zydis
Zyan Core Library for C is an internal library providing platform independent
types, macros and a fallback for environments without LibC.
2023-02-25T09:26:25-08:00 misc/binbloom Raw binary firmware analysis software
The purpose of the binbloom project is to analyse a raw binary firmware and
determine automatically some of its features. This tool is compatible with all
architectures as basically, it just does simple statistics on it.

Main features:
* Loading address: binbloom can parse a raw binary firmware and determine its
loading address.
* Endianness: binbloom can use heuristics to determine the endianness of a
firmware.
* UDS Database: binbloom can parse a raw binary firmware and check if it
contains an array containing UDS command IDs.
2023-02-25T17:55:32+01:00 net-p2p/nomadnet Off-grid, resilient mesh communication
Nomad Network allows you to build private and resilient communications
platforms that are in complete control and ownership of the people that use
them. No signups, no agreements, no handover of any data, no permissions and
gatekeepers.
2023-02-25T17:53:52+01:00 net-p2p/lxmf Lightweight Extensible Message Format for Reticulum
LXMF is a simple and flexible messaging format and delivery protocol that
allows a wide variety of implementations, while using as little bandwidth as
possible. It is built on top of Reticulum and offers zero-conf message routing,
end-to-end encryption and Forward Secrecy, and can be transported over any kind
of medium that Reticulum supports.
2023-02-25T08:27:17-06:00 biology/bcf-score Bcftools plugins for GWAS-VCF summary statistics files
Score is a set of tools in the form of a bcftools plugin, for handling
and converting summary statistics files following the GWAS-VCF
specification.
2023-02-25T15:24:18+01:00 net-p2p/reticulum Self-configuring, encrypted and resilient mesh networking stack
Reticulum is a cryptography-based networking stack for building local and
wide-area networks with readily available hardware. Reticulum can continue to
operate even in adverse conditions with very high latency and extremely low
bandwidth.
2023-02-25T01:46:54-08:00 devel/libvex Library for dynamic binary instrumentation and translation
LibVEX is a library for dynamic binary instrumentation and translation
that is normally a part of Valgrind.
2023-02-25T00:31:20+03:00 editors/linux-r7-office Russian office suite
R7 Office is a cross-platform Russian office suite accessible via cloud, mobile
and desktop interfaces. R7 allows collaborative editing of documents,
spreadsheets and presentations.
2023-02-15T20:02:45+03:00 textproc/obsidian Powerful and extensible knowledge base application
Obsidian is an Electron-based desktop application that allows creating a
knowledge base from Markdown-formatted notes. Notes can be connected and
visualized as a graph.
2023-02-24T13:29:47+09:00 net/qrcp Transfer files over wifi by scanning a QR code
Transfer files over Wi-Fi from your computer to a mobile device by
scanning a QR code without leaving the terminal.

qrcp binds a web server to the address of your Wi-Fi network interface
on a random port and creates a handler for it. The default handler
serves the content and exits the program when the transfer is
complete. When used to receive files, qrcp serves an upload page and
handles the transfer.
2023-02-22T09:56:27+03:00 editors/r7-office Russian office suite
R7 Office is a cross-platform Russian office suite accessible via cloud, mobile
and desktop interfaces. R7 allows collaborative editing of documents,
spreadsheets and presentations.
2023-02-23T08:23:12-08:00 devel/py-pyTooling Collection of arbitrary classes, decorators, meta-classes, exceptions
pyTooling is a powerful collection of arbitrary useful abstract data models,
classes, decorators, meta-classes and exceptions. It also provides lots of
helper functions e.g. to ease the handling of package descriptions.

It's useful for any Python-base project independent if it's a library,
framework or CLI tool.
2023-02-23T08:23:12-08:00 devel/py-itertree Python tree structure for data storage and iterations
itertree allows to:
* store data in a tree like structure
* has good performance
* has a reach feature set especially
* supportys serialization
* supports links to sub-trees
2023-02-23T10:40:42+00:00 print/harfbuzz-cairo Harfbuzz Cairo support
2023-02-22T17:26:36+01:00 sysutils/rust-coreutils Cross-platform Rust rewrite of the GNU coreutils
uutils is an attempt at writing universal (as in cross-platform) CLI utilities
in Rust. While all programs have been implemented, some options might be
missing or different behavior might be experienced.
2023-02-06T00:02:43+03:00 ports-mgmt/rc-subr-jail Shell library to help writing RC scripts with jail support
This port install a shell source intended to be included by rc scripts that
want to run services inside a jail.

2023-02-22T13:28:02+00:00 textproc/py-opensearch-py Python Client for OpenSearch
Python Client for OpenSearch
2023-02-22T13:20:00+00:00 devel/libfsfat Library and tools to access the File Allocation Table File System
Library and tools to access the File Allocation Table (FAT) file system
2023-02-22T13:14:46+00:00 devel/libphdi Library and tools to access the Parallels Hard Disk image format
Library and tools to access the Parallels Hard Disk image (PHDI) format.
2023-02-22T03:56:50-08:00 audio/shuriken Shuriken beat slicer
Shuriken is an open source beat slicer for Linux which harnesses the power of
aubio's onset detection algorithms and Rubber Band's time stretching
capabilities. A simple Qt interface makes it easy to slice up drum loops, assign
individual drum hits to MIDI keys, and change the tempo of loops in real-time.
The JUCE library takes care of handling audio and MIDI behind the scenes.
2023-02-22T07:58:32+01:00 www/py-dj41-drf-yasg Yet Another Swagger Generator
Generate real Swagger/OpenAPI 2.0 specifications from a Django Rest
Framework API.

Features:

- full support for nested serializers and schemas
- response schemas and descriptions
- model definitions compatible with codegen tools
- customization hooks at all points in the spec generation process
- JSON and YAML format for spec
- bundles latest version of swagger-ui and redoc for viewing the generated
documentation
- schema view is cacheable out of the box
- generated Swagger schema can be automatically validated by
swagger-spec-validator or flex
- supports Django REST Framework API versioning with URLPathVersioning
and NamespaceVersioning (other DRF or custom versioning schemes are
not currently supported)
2023-02-22T07:58:32+01:00 www/py-dj41-djangorestframework Django REST framework
Django REST framework is a powerful and flexible toolkit that makes
it easy to build Web APIs.
2023-02-22T07:58:32+01:00 www/py-dj41-django-timezone-field Provides database and form fields for pytz timezone objects for Django
Provides database and form fields for pytz timezone objects for Django.
2023-02-22T07:58:32+01:00 www/py-dj41-django-taggit Reusable Django application for simple tagging
django-taggit a simpler approach to tagging with Django.
2023-02-22T07:58:32+01:00 www/py-dj41-django-tables2 Table/data-grid framework for Django
django-tables2 simplifies the task of turning sets of data into HTML tables.
It has native support for pagination and sorting, does for HTML tables what
django.forms does for HTML forms.
2023-02-22T07:58:32+01:00 www/py-dj41-django-rich Extensions for using Rich with Django
This package provides Extensions for using Rich with the Django framework.

These extensions consist of the following subclasses:

* django_rich.management.RichCommand:
Subclass of Django's BaseCommand class that sets its self.console to a
Rich Console.

* django_rich.test.RichRunner:
Subclass of Django's DiscoverRunner with colourized outputs and nice
traceback rendering.
2023-02-22T07:58:32+01:00 www/py-dj41-django-redis Full featured Redis cache/session backend for Django
Django-redis is a BSD Licensed, full featured Redis cache/session
backend for Django.

Why use django-redis?

* Modular client system (pluggable clients).
* Master-Slave support in the default client.
* Used in production in several projects as cache and session storage.
* Supports infinite timeouts.
* Python 3 support in same code base.
* Facilities for raw access to Redis client/connection pool.
* Highly configurable (can emulate memcached exception behavior, for
example).
* Unix sockets supported by default.
* Pluggable parsers.
2023-02-22T07:58:32+01:00 www/py-dj41-django-prometheus Export Django monitoring metrics for Prometheus.io
This library exports Django monitoring metrics for Prometheus.io.

It provides support to monitor the following databases types:

* SQLite (via Django)
* PostgreSQL
* MySQL

In addition, caches can also be monitored:

* memcached
* Redis

It's even possible to export metrics of Django models and migrations.
2023-02-22T07:58:32+01:00 www/py-dj41-django-mptt Utilities for implementing Modified Preorder Tree Traversal in Django
Utilities for implementing Modified Preorder Tree Traversal with your Django
Models and working with trees of Model instances.
2023-02-22T07:58:32+01:00 www/py-dj41-django-js-asset Insert script tags with additional attributes for django.forms.Media
Insert script tags with additional attributes (such as "id" and "data" for
CSP-compatible data injection) for the django.forms.Media package.
2023-02-22T07:58:32+01:00 www/py-dj41-django-graphiql-debug-toolbar Django Debug Toolbar for GraphiQL IDE
This package is an extension for Django Debug Toolbar which enables support
for debugging GraphiQL queries in Django Projects.
2023-02-22T07:58:32+01:00 www/py-dj41-django-filter Dynamic filtering for querysets with Django
Django-filter is a reusable Django application allowing users to declaratively
add dynamic QuerySet filtering from URL parameters.
2023-02-22T07:58:32+01:00 www/py-dj41-django-debug-toolbar Configurable set of panels to display debug information
The Django Debug Toolbar is a configurable set of panels that display various
debug information about the current request/response and when clicked, display
more details about the panel's content.
2023-02-22T07:58:32+01:00 www/py-dj41-django-cors-headers Handles server headers required for Cross-Origin Resource Sharing
A Django App that adds CORS (Cross-Origin Resource Sharing) headers to
responses.
2023-02-22T07:58:32+01:00 www/py-dj41-django-auth-ldap LDAP integration for django.contrib.auth
This is a Django authentication backend that authenticates against an LDAP
service. Configuration can be as simple as a single distinguished name template,
but there are many rich configuration options for working with users, groups,
and permissions.
2023-02-22T07:58:32+01:00 devel/py-dj41-graphene-django Graphene Django integration
A Django integration for Graphene.
2023-02-22T07:58:32+01:00 devel/py-dj41-django-rq Provides Django integration for RQ (Redis Queue)
Django integration with RQ, a Redis based Python queuing library. Django-RQ is a
simple app that allows you to configure your queues in django's settings.py and
easily use them in your project.
2023-02-21T00:44:09-08:00 devel/py-lazy_loader Load subpackages and functions on demand easily
lazy_loader serves these purposes:
* Allow subpackages to be made visible to users without incurring import costs
* Allow external libraries to be imported only when used, improving import times
2023-02-20T23:44:47-08:00 audio/py-soxr High quality, one-dimensional sample-rate conversion library
soxr is a high quality, one-dimensional sample-rate conversion library
for Python.
2023-02-20T23:12:11-08:00 deskutils/spacefm SpaceFM file manager
SpaceFM is a multi-panel tabbed file and desktop manager for Linux with built-in
VFS, udev- or HAL-based device manager, customisable menu system, and bash-GTK
integration. SpaceFM aims to provide a stable, capable file manager with
significant customisation capabilities.
2023-02-16T22:06:31+01:00 security/ssh-import-id Authorize SSH public keys from trusted online identities
You're logged onto a cloud instance working on a problem with your
fellow devs, and you want to invite them to log in and take a look
at these crazy log messages. What to do?

Oh. You have to ask them to cat their public SSH key, paste it into
IRC (wait, no, it's id_rsa.pub, not id_rsa silly!) then you copy it
and cat it to the end of authorized_hosts.

That's where ssh-import-id comes in. With ssh-import-id, you can add
the public SSH keys from a known, trusted online identity to grant
SSH access.

Currently supported identities include Github and Launchpad.
2023-02-20T16:51:44+01:00 audio/gtultra Music tracker for the C64, fork of goattracker
GTUltra is an extensively modified GoatTracker Stereo (2.76) version.
It includes many new features.
2023-02-18T14:34:09+03:00 devel/appstream-compose AppStream Compose application and library
2023-02-20T08:46:17+01:00 devel/bencodetools Collection of tools for manipulating bencoded data
bencode-tools is a collection of tools for manipulating bencoded data.

Bencode (pronounced like Bee-encode) is the encoding used by the
peer-to-peer file sharing system BitTorrent for storing and transmitting
loosely structured data.
2023-02-19T20:03:56+09:00 deskutils/libportal-qt5 GIO-styled async APIs for Flatpak (${BACKEND} backend)
2023-02-19T20:03:56+09:00 deskutils/libportal-gtk4 GIO-styled async APIs for Flatpak (${BACKEND} backend)
2023-02-19T20:03:56+09:00 deskutils/libportal-gtk3 GIO-styled async APIs for Flatpak (${BACKEND} backend)
2023-02-09T17:53:16+01:00 security/openssl-agent OpenSSL key agent and client utilities
OpenSSL key agent and client utilities

The aim of these utilities is to provide an openssl-rsautl(1) drop-in
replacement for performing cryptographic operations using a private key
that is unlocked for the session, similar to OpenSSH's ssh-agent(1).
2023-02-09T17:52:12+01:00 devel/build2 Cross-platform toolchain for building and packaging C++ code
build2 is an open source (MIT), cross-platform build toolchain that aims to
approximate Rust Cargo's convenience for developing and packaging C/C++
projects while providing more depth and flexibility, especially in the build
system.
2023-02-18T10:46:51+01:00 math/kalk Kalk is a convergent calculator for Plasma
Kalk is a convergent calculator for Plasma.
2023-02-18T09:36:54+01:00 net/alligator Kirigami-based RSS reader
Alligator is a mobile feed reader.
2023-02-17T23:36:57-08:00 lang/hs-futhark Data-parallel functional programming language
Futhark is a purely functional data-parallel programming language in the
ML family. It can be compiled to typically very efficient parallel code, running
on either a CPU or GPU. The language is developed at DIKU at the University of
Copenhagen, originally as part of the HIPERFIT centre. It is quite stable and
suitable for practical programming.
2023-02-17T21:03:34+01:00 multimedia/plasmatube Elegant user interface for YouTube
PlasmaTube allows you to watch YouTube videos on your phone or desktop using a
elegant user interface integrated with the rest of Plasma.
2023-02-17T15:05:27+01:00 graphics/drm-515-kmod DRM drivers modules
amdgpu, i915, and radeon DRM drivers modules.
Currently corresponding to Linux 5.15 DRM.
This version is for FreeBSD 14.0 and above.
2023-02-16T16:17:54+03:00 devel/glibd D language bindings for the GLib Utility Library
GlibD is a Glib/GTK bindings library for the D programming language.
2023-02-16T15:26:59+03:00 lang/gir-to-d Create D bindings from GObject introspection files
girtod is an utility that generates D bindings using the GObject introspection
files.
2023-02-17T00:59:25-08:00 cad/hs-verismith Verilog fuzzer
verismith is a Verilog fuzzer to test the major simulators and sythesisers by
generating random, valid Verilog.
2023-02-15T11:15:04-08:00 sysutils/cfengine321 Systems administration tool for networks
Cfengine is an automated suite of programs for configuring and
maintaining Unix-like computers. It has been used on computing arrays
of between 1 and 20,000 computers since 1993 by a wide range of
organizations. Cfengine is supported by active research and was the
first autonomic, hands-free management system for Unix-like operating
systems. Cfengine is an autonomic maintenance system not merely a
change management roll-out tool. Cfengine has a history of security
and adaptability.
2023-02-15T11:15:04-08:00 sysutils/cfengine-masterfiles321 cfengine sample policies for installations and upgrades
CFEngine 3 is a popular open source configuration management system.
Its primary function is to provide automated configuration and
maintenance of large-scale computer systems.

The repository is intended to provide a stable base policy for
installations and upgrades, and is used by CFEngine 3.6 and newer.
The port installs the repository as examples which should be copied by
the user to the masterfiles directory (usually /var/cfengine/masterfiles).
2023-02-01T23:33:40+02:00 sysutils/sndy Sound Switcher
sndy is an audio switching program that allows you to redirect sound
output to any port of your computer. The buttons in the program toggle
the sound output to a different device. The scroll bar can be used to
change the volume level.
2023-02-14T18:30:04+01:00 devel/signal-fts5-extension FTS5 extension for signal_tokenizer
Signal-FTS5-Extension is a C ABI library which exposes a FTS5 tokenizer function
named signal_tokenizer that:

Segments UTF-8 strings into words according to Unicode standard
Normalizes and removes diacritics from words
Converts words to lower case

When used as a custom FTS5 tokenizer this enables application to support CJK
symbols in full-text search.
2023-02-13T16:18:58+00:00 sysutils/libdisplay-info EDID and DisplayID library
EDID and DisplayID library.

Goals:

- Provide a set of high-level, easy-to-use, opinionated functions as well as
low-level functions to access detailed information.
- Simplicity and correctness over performance and resource usage.
- Well-tested and fuzzed.
2023-02-11T22:55:57+01:00 net-im/tokodon KDE mastodon client
Tokodon is a Mastodon client for Plasma.

It allows you to interact with the Fediverse community.
2023-02-09T16:39:46+03:00 devel/appstream-qt Qt bindings to AppStream
2023-02-13T01:06:49-08:00 math/py-py-find-1st Numpy extension module for efficient search in numpy arrays
py_find_1st is a numpy extension that allows to find the first index into an
1D-array that validates a boolean condition that can consist of a comparison
operator and a limit value.
2023-02-12T23:45:19-08:00 finance/py-technical Various indicators developed or collected for the Freqtrade
Technical is a collection of technical indicators collected or developed for
Freqtrade as well as utilities such as timeframe resampling.
2023-02-12T22:07:29-08:00 finance/py-pycoingecko Python wrapper around the CoinGecko API
pycoingecko is Pi ython wrapper for the CoinGecko API.

CoinGecko provides information about cryptocurrency prices, excghange rates,
market caps, etc.
2023-02-11T13:02:46+01:00 sysutils/uutils Cross-platform Rust rewrite of the GNU coreutils
uutils is an attempt at writing universal (as in cross-platform) CLI utilities
in Rust. While all programs have been implemented, some options might be
missing or different behavior might be experienced.
2023-02-08T20:30:47+03:00 textproc/gstreamer1-plugins-zxing GStreamer plugin for QR recognition
2023-02-10T11:41:30+00:00 devel/edi EFL-based/focused IDE
This is a project to create a complete IDE using the EFL (Enlightenment
Foundation Libraries). It aims to lower the barrier to getting involved
in Enlightenment development and in creating applications based on the
EFL suite, but can also be used as an advanced, standalone text editor.
2023-02-01T16:26:31+00:00 benchmarks/vkoverhead Evaluate CPU overhead of Vulkan drivers
vkoverhead is a tool for evaluating CPU-based overhead of Vulkan
drivers. It was inspired heavily by drawoverhead from piglit.

## Features
* extreme granularity for profiling specific scenarios
* simple to use
* CSV output for ease of script parsing
* zero dependencies
2023-02-08T00:05:31+09:00 net/tigervnc-viewer-java TigerVNC Viewer
This port provides Java version client(viewer) compornents of TigerVNC.

TigerVNC is a high-performance, platform-neutral implementation of VNC,
a client/server application that allows users to launch and interact with
graphical applications on remote machines.
2023-02-06T08:23:55-08:00 math/kissat Kissat SAT Solver
KISSAT is a "keep it simple and clean bare metal SAT solver" written in
C. It is a port of CaDiCaL back to C with improved data structures,
better scheduling of inprocessing and optimized algorithms and
implementation. Coincidentally 'kissat' also means 'cats' in Finnish.
2023-02-06T19:04:21+00:00 x11/waylock Small screenlocker for Wayland compositors
Waylock is a small screenlocker for Wayland compositors implementing
ext-session-lock-v1. The ext-session-lock-v1 protocol is significantly
more robust than previous client-side Wayland screen locking approaches.
Importantly, the screenlocker crashing does not cause the session to be
unlocked.
2023-02-06T17:03:45+01:00 print/py-pydyf Low-level PDF generator based on PDF spec 1.7
A low-level PDF generator written in Python and based
on PDF specification 1.7.
2023-02-05T19:23:23+01:00 archivers/ancient Decompression routines for ancient formats
ancient is a collection of decompression routines for old formats popular in the
Amiga, Atari computers and some other systems from 80's and 90's as well as some
that are currently used which were used in a some specific way in these old
systems. For simple usage both a simple command line application as well as a
simple API to use the decompressors are provided. The compression algorithm is
automatically detected in most cases, however there are some corner cases where
it is not entirely reliable due to weaknesses in the old format used.
2023-02-05T13:23:45-08:00 devel/py-hunter Flexible code tracing toolkit
Hunter is a flexible code tracing toolkit, not for measuring coverage, but for
debugging, logging, inspection and other nefarious purposes. It has a simple
Python API, a convenient terminal API and a CLI tool to attach to processes.
2023-02-05T13:33:51-08:00 devel/py-process-tests Tools for testing processes
process-tests is tools for testing processes.
2023-02-05T13:03:24-08:00 devel/py-fields Totally different take on container boilerplate
python-fields is a totally different take on container boilerplate.
2023-02-05T09:45:01-08:00 devel/nox Flexible test automation
nox is a command-line tool that automates testing in multiple Python
environments, similar to tox. Unlike tox, Nox uses a standard Python
file for configuration.
2023-02-05T23:15:23+08:00 www/rubygem-webrick17 HTTP server toolkit
WEBrick is an HTTP server toolkit that can be configured as an HTTPS server, a
proxy server, and a virtual-host server.

WEBrick features complete logging of both server operations and HTTP access.

WEBrick supports both basic and digest authentication in addition to algorithms
not in RFC 2617.

A WEBrick server can be composed of multiple WEBrick servers or servlets to
provide differing behavior on a per-host or per-path basis. WEBrick includes
servlets for handling CGI scripts, ERB pages, Ruby blocks and directory
listings.

WEBrick also includes tools for daemonizing a process and starting a process at
a higher privilege level and dropping permissions.
2023-02-05T23:15:20+08:00 devel/rubygem-concurrent-ruby-edge06 Bleeding edge features for concurrent-ruby
Contains features for concurrent-ruby that are under active development
and may change with future versions.
2023-02-05T23:15:20+08:00 devel/rubygem-concurrent-ruby11 Modern concurrency tools for Ruby
Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala,
Haskell, F#, C#, Java and classic concurrency patterns.
2023-02-05T23:15:19+08:00 devel/rubygem-bootsnap115 Boot large ruby/rails apps faster
Bootsnap makes booting large ruby/rails apps faster. It is a library that plugs
into a number of Ruby and (optionally) ActiveSupport and YAML methods to
optimize and cache expensive computations.
2023-02-05T23:15:18+08:00 devel/rubygem-aws-sdk-s31117 Official AWS Ruby gem for Amazon Simple Storage Service (Amazon S3)
Official AWS Ruby gem for Amazon Simple Storage Service (Amazon S3).
2023-02-05T23:15:17+08:00 devel/rubygem-aws-sdk-core3168 AWS SDK for Ruby - Core
Provides API clients for AWS. This gem is part of the official AWS SDK for
Ruby.
2023-02-05T23:15:16+08:00 science/py-cfgrib Map GRIB files to the NetCDF Common Data Model following the CF Convention using ecCodes
cfgrib provides a Python interface to map GRIB files to the Unidata's Common
Data Model v4 following the CF Conventions. The high level API is designed to
support a GRIB engine for xarray and it is inspired by netCDF4-python and
h5netcdf. Low level access and decoding is performed via the ECMWF ecCodes
library and the eccodes python package.
2023-02-05T23:15:14+08:00 devel/py-sparse Sparse n-dimensional arrays
This implements sparse arrays of arbitrary dimension on top of numpy and
scipy.sparse. It generalizes the scipy.sparse.coo_matrix and
scipy.sparse.dok_matrix layouts, but extends beyond just rows and columns to an
arbitrary number of dimensions.

Additionally, this project maintains compatibility with the numpy.ndarray
interface rather than the numpy.matrix interface used in scipy.sparse

These differences make this project useful in certain situations where
scipy.sparse matrices are not well suited, but it should not be considered a
full replacement. The data structures in pydata/sparse complement and can be
used in conjunction with the fast linear algebra routines inside scipy.sparse. A
format conversion or copy may be required.
2023-02-05T23:15:13+08:00 devel/py-pycomplete Python library to generate static completion scripts for your CLI app
With pycomplete, one can generate a completion script for CLI application that
is compatible with a given shell. The script outputs the result onto stdout,
allowing one to re-direct the output to the file of their choosing.

pycomplete accepts different types of objects depending on which CLI framework
you are using. For argparse, argparse.ArgumentParser is expected while for
click, either click.Command or click.Context is OK. pycomplete knows what to do
smartly.

Where you place the file will depend on which shell, and which operating system
you are using. Your particular configuration may also determine where these
scripts need to be placed.

Note that pycomplete needs to be installed in the same environment as the target
CLI app to work properly.
2023-02-05T23:15:12+08:00 devel/phpunit10 Testing framework for unit tests
PHPUnit is a programmer-oriented testing framework for PHP. It is an instance of
the xUnit architecture for unit testing frameworks.
2023-02-03T22:58:11-08:00 cad/py-cocotb Coroutine based cosimulation library for writing VHDL and Verilog
cocotb is an open source coroutine-based cosimulation testbench environment
for verifying VHDL and SystemVerilog RTL using Python.

cocotb lets you verify chips like software: productive, simulator-agnostic,
in Python.
2023-02-03T22:32:57-08:00 devel/py-find-libpython Finds the libpython associated with your environment
The find-libpython library is designed to find the path to the libpython dynamic
library for the current Python environment. It should work with many types of
installations, whether it be conda-managed, system-managed, or otherwise. And it
should function on Windows, Mac OS/OS X, and any Linux distribution.
2023-02-01T22:57:34-08:00 devel/py-interface-meta Expose an extensible API with enforced method signatures
interface_meta provides a convenient way to expose an extensible API with
enforced method signatures and consistent documentation.
2023-02-02T17:45:42-06:00 databases/mysql-connector-odbc-80 ODBC driver for MySQL${MYSQL_VER} / ${DRIVER_MANAGER}
MySQL Connector ODBC is an ODBC driver for interfacing to MySQL databases.
2023-02-02T16:21:04+01:00 mail/mlmmj-archive-mid CGI helping mapping a message id to an archived mail
CGI and cli program which will lookip all databases gerenated by mlmmj-archiver
and map a given message-id to its "public" archive file.
2023-02-02T07:09:18-05:00 lang/go120 Go programming language
2023-02-01T20:10:03+01:00 audio/owntone DAAP (iTunes), MPD (Music Player Daemon) and RSP (Roku) media server
OwnTone is a DAAP (iTunes), MPD (Music Player Daemon) and RSP (Roku) media
server. It supports AirPlay devices/speakers, Apple Remote (and compatibles),
MPD clients, Chromecast, network streaming, internet radio, Spotify and LastFM.

It does not support streaming video by AirPlay nor Chromecast.

DAAP stands for Digital Audio Access Protocol which is the protocol used by
iTunes and friends to share/stream media libraries over the network.

OwnTone was previously called forked-daapd, which again was a rewrite of
mt-daapd (Firefly Media Server).
2023-01-31T14:10:31+02:00 net/rubygem-app_store_connect Interface to the App Store Connect API
A Ruby interface to the App Store Connect API
2023-02-01T00:35:00-08:00 x11-toolkits/pythonqt Dynamic Python binding for Qt Applications
PythonQt is a dynamic Python binding for Qt. It offers an easy way to embed the
Python scripting language into your Qt applications.
2023-01-31T18:42:03-08:00 deskutils/keep-presence Prevent system from becoming idle
keep-presence is a program moves the mouse or press a key when it detects that
you are away.
It won't do anything if you are using your computer.
Useful to trick your machine to think you are still working with it.
2023-01-31T08:01:01-08:00 x11/py-pynput Send virtual input commands
pynput is the library allows you to control and monitor input devices.

Currently, mouse and keyboard input and monitoring are supported.
2023-01-30T20:13:16+03:00 games/powder-toy-devel 'Falling sand' physics sandbox with air pressure and velocity support (snapshot version)
Have you ever wanted to blow something up? Or maybe you always
dreamt of operating an atomic power plant? Do you have a will to
develop your own CPU? The Powder Toy lets you to do all of these,
and even more!

The Powder Toy is a free physics sandbox game, which simulates air
pressure and velocity, heat, gravity and a countless number of
interactions between different substances! The game provides you
with various building materials, liquids, gases and electronic
components which can be used to construct complex machines, guns,
bombs, realistic terrains and almost anything else. You can then
mine them and watch cool explosions, add intricate wirings, play
with little stickmen or operate your machine. You can browse and
play thousands of different saves made by the community or upload
your own - we welcome your creations!
2023-01-31T07:48:59+08:00 devel/py-pyyaml5 Python YAML parser
PyYAML is a YAML parser and emitter for the Python programming language.

PyYAML features:
* a complete YAML 1.1 parser. In particular, PyYAML can parse all examples
from the specification. The parsing algorithm is simple enough to be a
reference for YAML parser implementors.
* Unicode support including UTF-8/UTF-16 input/output and \u escape
sequences.
* low-level event-based parser and emitter API (like SAX).
* high-level API for serializing and deserializing native Python objects
(like DOM or pickle).
* support for all types from the YAML types repository. A simple extension
API is provided.
* relatively sensible error messages.
2023-01-30T23:38:36+00:00 devel/llvm16 LLVM and Clang
The LLVM Project is a collection of modular and reusable compiler and
toolchain technologies.

This port includes Clang (a C/C++/Objective-C compiler), LLD (a linker),
LLDB (a debugger), an OpenMP runtime library, and the LLVM infrastructure
these are built on.
2023-01-30T23:02:55+02:00 devel/rubygem-simple_po_parser Simple PO file to ruby hash parser
A simple PO file to ruby hash parser.
PO files are translation files generated by GNU/Gettext tool.
2023-01-30T13:09:02-06:00 biology/wfa2-lib Exact gap-affine algorithm using homology to accelerate alignment
The wavefront alignment (WFA) algorithm is an exact gap-affine
algorithm that takes advantage of homologous regions between the
sequences to accelerate the alignment process. Unlike traditional
dynamic programming algorithms that run in quadratic time, the WFA runs
in time O(ns+s^2), proportional to the sequence length n and the
alignment score s, using O(s^2) memory (or O(s) using the
ultralow/BiWFA mode). Moreover, the WFA algorithm exhibits simple
computational patterns that the modern compilers can automatically
vectorize for different architectures without adapting the code.
2023-01-30T22:20:38+08:00 www/yarn-node19
2023-01-30T22:20:38+08:00 www/npm-node19
2023-01-30T22:20:38+08:00 www/node19 V8 JavaScript for client and server
Node.js is a JavaScript runtime built on Chrome's V8 JavaScript engine. Node.js
uses an event-driven, non-blocking I/O model that makes it lightweight and
efficient. Node.js' package ecosystem, npm, is the largest ecosystem of open
source libraries in the world.
2023-01-30T22:20:38+08:00 www/node18 V8 JavaScript for client and server
Node.js is a JavaScript runtime built on Chrome's V8 JavaScript engine. Node.js
uses an event-driven, non-blocking I/O model that makes it lightweight and
efficient. Node.js' package ecosystem, npm, is the largest ecosystem of open
source libraries in the world.
2023-01-30T20:22:03+08:00 www/rubygem-jwt25 JSON Web Token implementation in Ruby
JWT is a Ruby implementation of JSON Web Token draft 06 [1].

[1] http://self-issued.info/docs/draft-jones-json-web-token-06.html
2023-01-30T20:22:00+08:00 textproc/rubygem-gemoji3 Character information and metadata for Unicode emoji
Emoji assets
2023-01-30T20:21:57+08:00 net/rubygem-rbvmomi2 Ruby interface to the VMware vSphere API
RbVmomi is a Ruby interface to the vSphere API. Like the Perl and Java SDKs, you
can use it to manage ESX and vCenter servers.

RbVmomi2 is a community-supported, open source project at ManageIQ.
2023-01-30T20:21:53+08:00 mail/rubygem-mail27 Ruby email handler
Mail is an library for Ruby to handle email generation,
parsing and sending in a simple, rubyesque manner.
2023-01-30T20:21:51+08:00 devel/rubygem-xdg6 XDG Base Directory Standard Library for Ruby
XDG provides an easy to use Ruby library for working with XDG standards.

Presently, it only supports the XDG Base Directory Standard.

If your program utilizes user or system-wide support files (e.g. configuration
files), you owe it to yourself to checkout the XDG base directory standard.

You can learn more about the standard at:
http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
2023-01-30T20:21:50+08:00 devel/rubygem-syntax_suggest Help you find the syntax when you get an "unexpected end"
An error in your code forces you to stop. SyntaxSuggest helps you find those
errors to get you back on your way faster.
2023-01-30T20:21:49+08:00 devel/rubygem-sidekiq-cron18 Enables to set jobs to be run in specified time (using CRON notation)
Sidekiq-Cron is a scheduling add-on for Sidekiq.

It runs a thread alongside Sidekiq workers to schedule jobs at specified times
(using cron notation * * * * * parsed by Rufus-Scheduler).

It also checks for new jobs to schedule every 10 seconds and doesn't schedule
the same job multiple times when more than one Sidekiq worker is running.

Scheduling jobs are added only when at least one Sidekiq process is running.
2023-01-30T20:21:48+08:00 devel/rubygem-sidekiq6 Simple, efficient background processing for Ruby
Simple, efficient background processing for Ruby

See also: https://github.com/mperham/sidekiq
2023-01-30T20:21:47+08:00 devel/rubygem-rubocop-capybara Code style checking for Capybara test files
RuboCop Capybara provides Capybara-specific analysis for your projects, as an
extension to RuboCop.
2023-01-30T20:21:46+08:00 devel/rubygem-redlock Distributed lock using Redis written in Ruby
Redlock provides a ruby distributed lock using redis.

Distributed locks are a very useful primitive in many environments where
different processes require to operate with shared resources in a mutually
exclusive way.

There are a number of libraries and blog posts describing how to implement a DLM
(Distributed Lock Manager) with Redis, but every library uses a different
approach, and many use a simple approach with lower guarantees compared to what
can be achieved with slightly more complex designs.

This is an implementation of a proposed distributed lock algorithm with Redis.
It started as a fork from antirez implementation.
2023-01-30T20:21:45+08:00 devel/rubygem-gettext-setup0 Set up i18n for Ruby projects
gettext-setup is a simple gem to set up i18n for Ruby projects (including
Sinatra web apps) using gettext and fast gettext.

This project sets the default locale to English. If the user has set a different
locale in their browser preferences, and we support the user's preferred locale,
strings and data formatting will be customized for that locale.
2023-01-30T20:21:43+08:00 devel/rubygem-fugit17 Time tools for flor and the floraison project
Fugit is a time tools for flor and the floraison group. It uses et-orbi to represent
time instances and raabro as a basis for its parsers. Fugit will probably become
the foundation for rufus-scheduler 4.x
2023-01-30T20:21:42+08:00 devel/rubygem-flipper025 Act of enabling/disabling features in your application
Feature flipping is the act of enabling or disabling features or parts of your
application, ideally without re-deploying or changing anything in your code
base.

The goal of this gem is to make turning features on or off so easy that everyone
does it. Whatever your data store, throughput, or experience, feature flipping
should be easy and have minimal impact on your application.
2023-01-30T20:21:41+08:00 devel/rubygem-cucumber-tag-expressions4 Cucumber tag expressions for Ruby
Tag Expressions provide a simple query language for tags. The simplest tag
expression is simply a single tag.
2023-01-30T20:21:40+08:00 devel/rubygem-bootsnap114 Boot large ruby/rails apps faster
Bootsnap makes booting large ruby/rails apps faster. It is a library that plugs
into a number of Ruby and (optionally) ActiveSupport and YAML methods to
optimize and cache expensive computations.
2023-01-30T20:21:39+08:00 devel/rubygem-aws-sdk-simspaceweaver Official AWS Ruby gem for AWS SimSpace Weaver
Official AWS Ruby gem for AWS SimSpace Weaver.
2023-01-30T20:21:38+08:00 devel/rubygem-aws-sdk-securitylake Official AWS Ruby gem for Amazon Security Lake
Official AWS Ruby gem for Amazon Security Lake.
2023-01-30T20:21:36+08:00 devel/rubygem-aws-sdk-sagemakermetrics Official AWS Ruby gem for Amazon SageMaker Metrics Service (SageMaker Metrics)
Official AWS Ruby gem for Amazon SageMaker Metrics Service (SageMaker Metrics).
2023-01-30T20:21:35+08:00 devel/rubygem-aws-sdk-sagemakergeospatial Official AWS Ruby gem for Amazon SageMaker geospatial capabilities
Official AWS Ruby gem for Amazon SageMaker geospatial capabilities.
2023-01-30T20:21:34+08:00 devel/rubygem-aws-sdk-pipes Official AWS Ruby gem for Amazon EventBridge Pipes
Official AWS Ruby gem for Amazon EventBridge Pipes.
2023-01-30T20:21:33+08:00 devel/rubygem-aws-sdk-opensearchserverless Official AWS Ruby gem for OpenSearch Service Serverless
Official AWS Ruby gem for OpenSearch Service Serverless.
2023-01-30T20:21:32+08:00 devel/rubygem-aws-sdk-omics Official AWS Ruby gem for Amazon Omics
Official AWS Ruby gem for Amazon Omics.
2023-01-30T20:21:31+08:00 devel/rubygem-aws-sdk-oam Official AWS Ruby gem for CloudWatch Observability Access Manager
Official AWS Ruby gem for CloudWatch Observability Access Manager.
2023-01-30T20:21:29+08:00 devel/rubygem-aws-sdk-licensemanagerlinuxsubscriptions Official AWS Ruby gem for AWS License Manager Linux Subscriptions
Official AWS Ruby gem for AWS License Manager Linux Subscriptions.
2023-01-30T20:21:28+08:00 devel/rubygem-aws-sdk-kinesisvideowebrtcstorage Official AWS Ruby gem for Amazon Kinesis Video WebRTC Storage
Official AWS Ruby gem for Amazon Kinesis Video WebRTC Storage.
2023-01-30T20:21:27+08:00 devel/rubygem-aws-sdk-kendraranking Official AWS Ruby gem for Amazon Kendra Intelligent Ranking (Kendra Ranking)
Official AWS Ruby gem for Amazon Kendra Intelligent Ranking (Kendra Ranking).
2023-01-30T20:21:26+08:00 devel/rubygem-aws-sdk-docdbelastic Official AWS Ruby gem for Amazon DocumentDB Elastic Clusters (DocDB Elastic)
Official AWS Ruby gem for Amazon DocumentDB Elastic Clusters (DocDB Elastic).
2023-01-30T20:21:25+08:00 devel/rubygem-aws-sdk-codecatalyst Official AWS Ruby gem for Amazon CodeCatalyst
Official AWS Ruby gem for Amazon CodeCatalyst.
2023-01-30T20:21:24+08:00 devel/rubygem-aws-sdk-cleanrooms Official AWS Ruby gem for AWS Clean Rooms Service
Official AWS Ruby gem for AWS Clean Rooms Service.
2023-01-30T20:21:22+08:00 devel/rubygem-aws-sdk-arczonalshift Official AWS Ruby gem for AWS ARC - Zonal Shift
Official AWS Ruby gem for AWS ARC - Zonal Shift.
2023-01-30T20:21:21+08:00 databases/rubygem-redis-namespace19 Ruby client class for Redis with namespace support
Adds a Redis::Namespace class which can be used to namespace calls to Redis.
This is useful when using a single instance of Redis with multiple, different
applications.
2023-01-30T20:21:20+08:00 www/py-xandikos Lightweight CalDAV/CardDAV server
Xandikos is a lightweight yet complete CardDAV/CalDAV server that backs onto a
Git repository.

Xandikos takes its name from the name of the March month in the ancient
Macedonian calendar, used in Macedon in the first millennium BC.
2023-01-30T20:21:17+08:00 textproc/py-rich12 Rich text and beautiful formatting in the terminal
Rich is a Python library for rich text and beautiful formatting in the
terminal.

The Rich API makes it easy to add color and style to terminal
output. Rich can also render pretty tables, progress bars, markdown,
syntax highlighted source code, tracebacks, and more -- out of the
box.
2023-01-30T20:21:15+08:00 textproc/py-grapheme Unicode grapheme helpers
grapheme is a Python package for working with user perceived characters. More
specifically, string manipulation and calculation functions for working with
grapheme cluster groups (graphemes) as defined by the Unicode Standard Annex
#29.
2023-01-30T20:21:12+08:00 security/py-pem Easy PEM file parsing in Python
pem is an MIT-licensed Python module for parsing and splitting of PEM files,
i.e. Base64-encoded DER keys and certificates.

It runs on Python 3.7+, has no dependencies, and does not attempt to interpret
the certificate data in any way.

It's born from the need to load keys, certificates, trust chains, and DH
parameters from various certificate deployments: some servers (like Apache)
expect them to be a separate file, others (like nginx) expect them concatenated
to the server certificate and finally some (like HAProxy) expect key,
certificate, and chain to be in one file.

Additionally to the vanilla parsing code, pem also contains helpers for Twisted
that save a lot of boilerplate code.
2023-01-30T20:21:08+08:00 science/py-asdf-unit-schemas ASDF schemas for units
asdf-unit-schemas provides ASDF schemas for validating unit tags. Users should
not need to install this directly; instead, install an implementation package
such as asdf-astropy, which includes asdf-unit-schemas as a dependency.
2023-01-30T20:21:07+08:00 misc/py-placekey Utilities for working with Placekeys
Placekey-py is a Python library for working with Placekeys. Documentation for
this package can be found here [1], and documentation for the Placekey service
API can be found here [2]. The Plackey design specification is available here
[3].

[1] https://placekey.github.io/placekey-py/
[2] https://docs.placekey.io/
[3] https://docs.placekey.io/Placekey_Technical_White_Paper.pdf
2023-01-30T20:21:04+08:00 devel/py-x-wr-timezone Python module and program to convert calendars using X-WR-TIMEZONE to standard ones
Some calendar providers introduce the non-standard X-WR-TIMEZONE parameter to
ICS calendar files. Strict interpretations according to RFC 5545 ignore the
X-WR-TIMEZONE parameter. This causes the times of the events to differ from
those which make use of X-WR-TIMEZONE.

This module aims to bridge the gap by converting calendars using X-WR-TIMEZONE
to a strict RFC 5545 calendars. So, let's put our heads together and solve this
problem for everyone!
2023-01-30T20:21:03+08:00 devel/py-recurring-ical-events Python module which repeats ICalendar events by RRULE, RDATE and EXDATE
ICal has some complexity to it: Events, TODOs and Journal entries can be
repeated, removed from the feed and edited later on. This tool takes care of
these circumstances.
2023-01-30T20:21:02+08:00 devel/py-pytest-mypy-plugins pytest plugin for writing tests for mypy plugins
pytest plugin for testing mypy types, stubs, and plugins.
2023-01-30T20:21:01+08:00 devel/py-pyproject_hooks Wrappers to call pyproject.toml-based build backend hooks
pyproject-hooks is a low-level library for calling build-backends in
pyproject.toml-based project. It provides the basic functionality to help write
tooling that generates distribution files from Python projects.

If you want a tool that builds Python packages, you'll want to use
devel/py-build instead. This is an underlying piece for pip, build and other
"build frontends" use to call "build backends" within them.
2023-01-30T20:20:59+08:00 devel/py-poetry Python dependency management and packaging made easy
Poetry is a tool for dependency management and packaging in Python. It allows
you to declare the libraries your project depends on and it will manage
(install/update) them for you.
2023-01-30T20:20:58+08:00 devel/py-packaging21 Core utilities for Python packages
packaging provides core utilities for Python packages.
2023-01-30T20:20:57+08:00 devel/py-jaraco.text Module for text manipulation
This package provides handy routines for dealing with text, such as wrapping,
substitution, trimming, stripping, prefix and suffix removal, line continuation,
indentation, comment processing, identifier processing, values parsing, case
insensitive comparison, and more. See the docs (linked in the badge above) for
the detailed documentation and examples.
2023-01-30T20:20:56+08:00 devel/py-dulwich020 Python Git Library
This is the Dulwich project.

It aims to provide an interface to git repos (both local and remote) that
doesn't call out to git directly but instead uses pure Python.
2023-01-30T20:20:55+08:00 devel/py-comm Jupyter Python Comm implementation
Comm provides a way to register a Kernel Comm implementation, as per the Jupyter
kernel protocol. It also provides a base Comm implementation and a default
CommManager that can be used.
2023-01-30T20:20:54+08:00 devel/py-about-time Easily measure timing and throughput of code blocks
about-time is a cool helper for tracking time and throughput of code blocks,
with beautiful human friendly renditions.
2023-01-30T20:20:52+08:00 devel/p5-match-simple-XS XS backend for match::simple
match::simple::XS provides the XS backend for match::simple.
2023-01-30T20:20:51+08:00 devel/p5-Future-AsyncAwait Deferred subroutine syntax for futures
Future::AsyncAwait provides syntax for deferring and resuming subroutines while
waiting for Futures to complete. This syntax aims to make code that performs
asynchronous operations using futures look neater and more expressive than
simply using then chaining and other techniques on the futures themselves. It is
also a similar syntax used by a number of other languages; notably C# 5,
EcmaScript 6, Python 3, Dart, Rust, C++20.

This module is still under active development. While it now seems relatively
stable enough for most use-cases and has received a lot of "battle-testing" in a
wide variety of scenarios, there may still be the occasional case of memory leak
left in it, especially if still-pending futures are abandoned.

The new syntax takes the form of two new keywords, async and await.
2023-01-30T12:27:14+00:00 games/openenroth Open reimplementation of Might and Magic VI-VIII game engine
Might and Magic VI-VIII engine remake using original data and code.
Allows playing the original game plus introduce customizations and
modifications. Currently, only MM7 is playable; support for 6 and
8 will be added in the future.
2023-01-30T12:02:28+01:00 accessibility/qt6-speech Accessibilty features for Qt6
As with the Qt 5 version, Qt Speech provides application developers with a
QObject subclass, QTextToSpeech, that provides an interface to the platform's
speech synthesizer engine; and a value type QVoice that encapsulates voice
characteristics. With those classes, applications can make themselves more
accessible to users, and go beyond the screen-reader functionality of assistive
technologies. Using non-visual channels to inform users about changes or events
can be very useful in hands-free situations, such as turn-by-turn navigation
systems. Content-focused applications like ebook readers could benefit from
text-to-speech synthesis without depending on assistive technology.
2023-01-29T23:18:07-08:00 net-mgmt/smartctl_exporter Prometheus metrics exporter for smartctl
smartctl_exporter exports smartctl json metrics to Prometheus.
2023-01-29T09:40:22-08:00 devel/poetry Python dependency management and packaging made easy
Poetry helps you declare, manage and install dependencies of Python projects,
ensuring you have the right stack everywhere.
2023-01-29T09:28:34-08:00 devel/py-poetry-plugin-export Poetry plugin to export the dependencies to various formats
Poetry plugin to export the dependencies to various formats.

This plugin provides the same features as the existing export command
of Poetry which it will eventually replace.
2023-01-29T09:15:41-08:00 devel/py-dulwich Python implementation of the Git file formats and protocols
Dulwich is a Python implementation of the Git file formats and protocols,
without the need to have Git installed.

It aims to provide an interface to Git repos (both local and remote) that
does not call out to Git directly but instead uses pure Python. All
functionality is available in pure Python. Optional C extensions can be
built for improved performance.
2023-01-29T00:47:58-08:00 devel/py-single-version Utility to define version string for Poetry-style Python project
single-version is a utility to let you have a single source of version in your
code base.

This utility targets modern Python projects which have layout generated by
Poetry, with a pyproject.toml file in place of setup.py.
2023-01-29T00:35:16-08:00 www/py-kiss-headers Parser and serializer for http headers
kiss-headers is a basic library, small and concise to help get things done
regarding headers in a better way.

Features:
* A backwards-compatible syntax using bracket style.
* Capability to alter headers using simple, human-readable operator
notation + and -.
* Flexibility if headers are from an email or HTTP, use as you need with one
library.
* Ability to parse any object and extract recognized headers from it, it also
supports UTF-8 encoded headers.
* Fully type-annotated.
* Provide great auto-completion in Python interpreter or any capable IDE.
* No dependencies. And never will be.
* 90% test coverage.
2023-01-28T19:10:22-08:00 net/librest1 GNOME REST library
librest has been designed to make it easier to access web services that claim
to be "RESTful". A reasonable definition of what this means can be found on
Wikipedia. However a reasonable description is that a RESTful service should
have urls that represent remote objects which methods can then be called on.
2023-01-28T18:40:15-08:00 net/geocode-glib2 Convenience library for the geocoding and reverse geocoding
geocode-glib is a convenience library for the geocoding (finding longitude,
and latitude from an address) and reverse geocoding (finding an address from
coordinates). It uses Nominatim service to achieve that. It also caches
(reverse-)geocoding requests for faster results and to avoid unnecessary server
load.
2023-01-27T22:45:40-08:00 devel/py-mypy-boto3-s3 Type annotations for boto3.S3 service
mypy-boto3-s3 contains type annotations for boto3.S3 1.26.58 service compatible
with VSCode, PyCharm, Emacs, Sublime Text, mypy, pyright and other tools.
2023-01-25T23:29:50+01:00 security/openvpn25 Secure IP/Ethernet tunnel daemon
OpenVPN is a robust, scalable and highly configurable VPN (Virtual Private
Network) daemon which can be used to securely link two or more private networks
using an encrypted tunnel over the internet. It can operate over UDP or TCP,
can use SSL or a pre-shared secret to authenticate peers, and in SSL mode, one
server can handle many clients.
2023-01-27T12:15:15+01:00 devel/electron22 Build cross-platform desktop apps with JavaScript, HTML, and CSS
Build cross platform desktop apps with JavaScript, HTML, and CSS.

It's easier than you think.

If you can build a website, you can build a desktop app. Electron is a
framework for creating native applications with web technologies like
JavaScript, HTML, and CSS. It takes care of the hard parts so you can
focus on the core of your application.
2023-01-26T00:50:13-08:00 math/py-disjoint-set Disjoint set data structure implementation for Python
disjoint-set is a DisjointSet (a.k.a. union-find data structure or merge-find
set) implementation for Python.
2023-01-25T14:56:31-07:00 sysutils/kapp Simple deployment tool for Kubernetes
kapp CLI encourages Kubernetes users to manage resources in bulk by working with
"Kubernetes applications" (sets of resources with the same label).
It focuses on resource diffing, labeling, deployment and deletion.
Unlike tools like Helm, kapp considers YAML templating and management of
packages outside of its scope,
though it works great with tools that generate Kubernetes configuration.
2023-01-25T01:20:22-08:00 multimedia/vvenc Versatile Video Coding (VVC) encoder
The Fraunhofer Versatile Video Encoder (VVenC) is a fast and efficient
H.266/VVC encoder implementation with the following main features:
- Easy to use encoder implementation with five predefined
quality/speed presets;
- Perceptual optimization to improve subjective video quality, based
on the XPSNR visual model;
- Extensive frame-level and task-based parallelization with very good
scaling;
- Frame-level single-pass and two-pass rate control supporting
variable bit-rate (VBR) encoding;
- Expert mode encoder interface available, allowing fine-grained
control of the encoding process.
2023-01-24T23:45:57-08:00 textproc/py-sentencepiece Unsupervised text tokenizer for Neural Network-based text generation
SentencePiece is an unsupervised text tokenizer and detokenizer mainly for
Neural Network-based text generation systems where the vocabulary size is
predetermined prior to the neural model training. SentencePiece implements
subword units (e.g., byte-pair-encoding (BPE)) and unigram language model
with the extension of direct training from raw sentences. SentencePiece
allows us to make a purely end-to-end system that does not depend on
language-specific pre/postprocessing.
2023-01-24T20:40:52+03:00 games/chromono Circular color puzzle
All those half-colored spheres could really need some help. And
with that, we obviously mean your help, otherwise this would probably
not be a game, but a movie or something. Grab those fully-colored
spheres and share the color (and the correct one at that) to bring
the world order back to normal. Sounds easy? It is. Up until the
third level or so. Then it gets tricky. But you'll figure it out,
I'm sure.
2023-01-24T10:10:53+00:00 net/haproxy26 Reliable, high performance TCP/HTTP load balancer
HAProxy is a free, very fast and reliable solution offering high
availability, load balancing, and proxying for TCP and HTTP-based
applications. It is particularly suited for web sites crawling under
very high loads while needing persistence or Layer7 processing.
2023-01-24T00:58:16-08:00 math/lmfit Library for Levenberg-Marquardt minimization and least-squares fitting
lmfit is a C library for Levenberg-Marquardt minimization and least-squares
fitting.
2023-01-24T00:33:11-08:00 math/libformfactor Library for computation of scattering form factors of polyhedra
libformfactor performs efficient computation of scattering form factors
(Fourier shape transforms) of arbitrary polyhedra.
2023-01-24T00:31:01-08:00 devel/libheinz C++ base library of Heinz Maier-Leibnitz Zentrum
libheinz is a C++ base library used in software developed at
Heinz Maier-Leibnitz Zentrum.
2023-01-23T22:59:36-08:00 math/libcerf Library that provides an implementation of complex error functions
libcerf is a self-contained numeric library that provides an efficient and
accurate implementation of complex error functions, along with Dawson,
Faddeeva, and Voigt functions.
2023-01-23T18:23:08+03:00 games/lbreakouthd Breakout-style arcade game
LBreakoutHD is a scaleable 16:9 remake of LBreakout2. You try to
clear levels full of different types of bricks and extras by using
your paddle to aim balls at the bricks.

All LBreakout2 themes and levelsets work. New themes can be of any
resolution.
2023-01-21T18:44:38-08:00 x11/py-screeninfo Fetch location and size of physical screens
Fetch location and size of physical screens
in Python programs.
2023-01-19T19:52:57+01:00 www/librewolf Custom version of Firefox, focused on privacy, security and freedom
LibreWolf is a free and open source web browser descended from the
Mozilla Application Suite. It is small, fast and easy to use, and offers
many advanced features:

o Popup Blocking
o Tabbed Browsing
o Live Bookmarks (ie. RSS)
o Extensions
o Themes
o FastFind
o Improved Security
2023-01-21T01:40:48-08:00 audio/py-pydub Manipulate audio with an simple and easy high level interface
Pydub allows to manipulate audio with a simple and easy high level interface
from Python code.
2023-01-21T01:15:10-08:00 audio/py-simpleaudio Simple, asynchronous audio playback for Python 3
simpleaudio is a simple audio playback Python extension - cross-platform,
asynchronous, dependency-free.
2023-01-21T00:18:51-08:00 graphics/py-moderngl-window Library for ModernGL making window creation & resource loading simple
moderngl-window is a cross platform utility library for ModernGL making window
creation and resource loading simple. It can also be used with PyOpenGL for
rendering with the programmable pipeline.
2023-01-20T23:23:58-08:00 misc/py-PyWavefront Library for importing Wavefront .obj files
PyWavefront reads Wavefront 3D object files (something.obj, something.obj.gz
and something.mtl) and generates interleaved vertex data for each material
ready for rendering.
2023-01-18T23:02:07+00:00 games/veloren-weekly Multiplayer voxel RPG written in Rust (weekly snapshot)
Veloren is a multiplayer voxel RPG written in Rust. Veloren takes
inspiration from games such as Cube World, Minecraft and Dwarf
Fortress. The game is currently under heavy development, but is
playable.

This is a weekly snapshot used on the official multiplayer server,
usually updated each Thursday.
2023-01-20T08:09:03-08:00 math/py-pyrr 3D mathematical functions using NumPy
Pyrr provides 3D mathematical functions using the power of NumPy.

Features:
* Object Oriented and Procedural interfaces
* Matrix (3x3, 4x4)
* Quaternion
* Vector (3D, 4D)
* Plane
* Ray
* Line / Line Segment (3D)
* Rectangle (2D)
* Axis Aligned Bounding Box (AABB / AAMBB)
* Geometric collision / intersection testing
2023-01-20T08:09:03-08:00 graphics/py-moderngl ModernGL: High performance rendering for Python 3
ModernGL is a python wrapper over OpenGL 3.3+ core that simplifies the creation
of simple graphics applications like scientific simulations, games or user
interfaces. Usually, acquiring in-depth knowledge of OpenGL requires a steep
learning curve. In contrast, ModernGL is easy to learn and use, moreover it is
capable of rendering with high performance and quality, with less code written.
The majority of the moderngl code base is also written in C++ for high
performance.
2023-01-20T08:09:03-08:00 graphics/py-glcontext Portable OpenGL context for Python
glcontext is a library providing OpenGL implementation for ModernGL on multiple
platforms:
* glcontext on github
* glcontext on pypi
* ModernGL
2023-01-20T08:09:03-08:00 math/py-mapbox-earcut Bindings for Pango for use with Manim
mapbox-earcut is python bindings for the C++ implementation of the Mapbox Earcut
library, which provides very fast and quite robust triangulation of 2D polygons.
2023-01-20T08:09:03-08:00 graphics/py-ManimPango Bindings for Pango for use with Manim
ManimPango is a C binding for Pango using Cython, which is internally used in
Manim to render (non-LaTeX) text.
2023-01-20T08:09:03-08:00 math/py-isosurfaces Construct isolines/isosurfaces over a 2D/3D scalar field
isosurfaces allows to construct isolines/isosurfaces of a 2D/3D scalar field
defined by a function, i.e. curves over which f(x,y)=0 or surfaces over which
f(x,y,z)=0. Most similar libraries use marching squares or similar over a
uniform grid, but this uses a quadtree to avoid wasting time sampling many far
from the implicit surface.
2023-01-20T08:09:03-08:00 benchmarks/ior IOR and mdtest, parallel IO storage benchmark
IOR is a parallel IO benchmark that can be used to test the performance of
parallel storage systems using various interfaces and access patterns. The IOR
repository also includes the mdtest benchmark which specifically tests the peak
metadata rates of storage systems under different directory structures. Both
benchmarks use a common parallel I/O abstraction backend and rely on MPI for
synchronization.
2023-01-17T20:32:43+01:00 net/kube-apiserver Kubernetes API service
The Kubernetes API server validates and configures data for the api
objects which include pods, services, replicationcontrollers,
and others. The API Server services REST operations and provides
the frontend to the cluster's shared state through which all other
components interact.
2023-01-17T18:29:54+01:00 comms/py-pymodbus Implementation of the Modbus protocol
Pymodbus is a full Modbus protocol implementation offering
asynchronous communications. It can also be used without any
third party dependencies (aside from pyserial) if a more
lightweight project is needed.
2023-01-20T01:00:59-08:00 sysutils/ior IOR and mdtest, parallel IO storage benchmark
IOR is a parallel IO benchmark that can be used to test the performance of
parallel storage systems using various interfaces and access patterns. The IOR
repository also includes the mdtest benchmark which specifically tests the peak
metadata rates of storage systems under different directory structures. Both
benchmarks use a common parallel I/O abstraction backend and rely on MPI for
synchronization.
2023-01-19T20:17:51-08:00 devel/shadered Lightweight, cross-platform & full-featured shader IDE
Shader debugger lets you easily find bugs in your shader code. It is simple to
use - you just need to pause the preview and select the pixel that you want to
debug. After starting the debugger, you will be able to:
* step through your shader code line by line
* run immediate expressions
* add watches
* place (conditional) breakpoints
* see list of all variables and their values
* hover over expressions and see their value
2023-01-19T07:44:11-08:00 science/py-vedo Python module for scientific analysis and visualization of 3D objects
Vedo is a lightweight and powerful python module for scientific analysis and
visualization of 3d objects.

The library includes a large set of working examples for a wide range of
functionalities:
* working with polygonal meshes and point clouds
* working with volumetric data and tetrahedral meshes
* plotting and histogramming in 2D and 3D
* integration with other libraries
2023-01-19T10:27:18+00:00 www/hedgedoc Web-based online collaborative editor using your preferred SQL DB
The best platform to write and share markdown.

HedgeDoc (formerly known as CodiMD) is an open-source, web-based,
self-hosted, collaborative markdown editor.

You can use it to easily collaborate on notes, graphs and even
presentations in real-time. All you need to do is to share your
note-link to your co-workers and they're ready to go.
2023-01-18T18:46:40-08:00 databases/diesel Extensible ORM and Query Builder for Rust
Diesel gets rid of the boilerplate for database interaction and eliminates
runtime errors without sacrificing performance. It takes full advantage of
Rust's type system to create a low overhead query builder that "feels like
Rust."

Supported databases:
1. PostgreSQL
2. MySQL
3. SQLite
2023-01-18T08:03:09-08:00 shells/atuin Magical shell history
Atuin replaces your existing shell history with a SQLite database, and records
additional context for your commands. Additionally, it provides optional and
*fully encrypted* synchronisation of your history between machines, via an Atuin
server.
2023-01-17T21:01:48-08:00 misc/py-einops New flavour of deep learning operations
einops provides flexible and powerful tensor operations for readable and
reliable code.
It supports numpy, pytorch, tensorflow, jax, and others.
2023-01-17T22:17:03+01:00 net-mgmt/gping Ping with graph
Ping, but with a graph.

Comes with the following super-powers:

* Graph the ping time for multiple hosts
* Graph the execution time for commands via the --cmd flag
* Custom colours
2023-01-17T18:05:01+01:00 sysutils/amazon-ssm-plugin Amazon AWS Manages shell experience using SSM APIs
This package provides Amazon SSM SessionManager and CLI for managing
shell experience using SSM APIs.

HOW TO USE:
aws ssm start-session --target "your instance-id"

SEE ALSO: https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html
2023-01-16T23:56:19-08:00 math/py-pyaudi Library implementing the algebra of Taylor polynomials
Audi (from latin: "listen") is an open source library that implements the
differential algebra of Taylor truncated polynomials and a few algorithms
useful for its applications (Differential Intelligence, automatic
differentiation, Taylor Models, etc.)
2023-01-16T23:53:39-08:00 math/audi Header only C++ library implementing the algebra of Taylor polynomials
Audi (from latin: "listen") is an open source, header only, C++ library (exposed
to python in the pyaudi package) that implements the differential algebra of
Taylor truncated polynomials and a few algorithms useful for its applications
(Differential Intelligence, automatic differentiation, Taylor Models, etc.)
2023-01-16T20:17:24-08:00 lang/antimony Antimony programming language
Antimony is a bullshit-free programming language that gets out of your way.
It is meant to "just work", without adding unnecessary and bloated language
features.

The goal of Antimony is to be a simple language that anyone - beginner and
expert - can pick up and use.
2023-01-16T12:50:37-08:00 cad/antimony CAD from a parallel universe
Antimony is a computer-aided design (CAD) tool from a parallel universe in which
CAD software evolved from Lisp machines rather than drafting tables.
2023-01-16T18:27:16+01:00 www/webtrees21 Online genealogy viewer (for PHP 7.4-8.2)
webtrees is the web's leading online collaborative genealogy
application. webtrees works from standard GEDCOM files, and is
therefore compatible with every major desktop application. webtrees
aims to be efficient and effective by using the right combination
of third-party tools, design techniques and open standards.
2023-01-16T01:36:02-08:00 textproc/sentencepiece Unsupervised text tokenizer for Neural Network-based text generation
SentencePiece is an unsupervised text tokenizer and detokenizer mainly for
Neural Network-based text generation systems where the vocabulary size is
predetermined prior to the neural model training. SentencePiece implements
subword units (e.g., byte-pair-encoding (BPE)) and unigram language model
with the extension of direct training from raw sentences. SentencePiece
allows us to make a purely end-to-end system that does not depend on
language-specific pre/postprocessing.
2023-01-16T10:21:14+01:00 net-p2p/tooth GTK Mastodon Client - Fork of Tootle
Tooth is a client for Mastodon, which is the world's largest
decentralized microblogging platform. The client provides a clean,
native interface, allowing the Mastodon social experience to be
seamlessly integrated into our desktop environment.

This client for Mastodon that It is characterized by three fundamental
aspects; be simple, free and open source. It should be added that this
tool is based on GTK with dark mode support.
2023-01-16T07:04:04+01:00 devel/ktextaddons Various text handling addons
Various text handling addons for the KDE dekstop
2023-01-15T17:31:51-08:00 devel/rxcpp Reactive eXtensions for C++
RxCpp is a header-only C++ library that only depends on the standard library.
2023-01-15T15:13:58-08:00 devel/phasar LLVM-based static analysis framework
PhASAR is a LLVM-based static analysis framework written in C++. It allows users
to specify arbitrary data-flow problems which are then solved in a
fully-automated manner on the specified LLVM IR target code. Computing points-to
information, call-graph(s), etc. is done by the framework, thus you can focus on
what matters.
2023-01-15T21:42:02+01:00 www/py-qt6-webengine Python bindings for the Qt6 toolkit, QtWebEngine module
PyQt6 is a set of Python bindings for Qt6 application framework.
This package provides the QtWebKit module.
2023-01-02T00:04:00-05:00 devel/py-setuptools58 Python packages installer
Setuptools is a fully-featured, actively-maintained, and stable library
designed to facilitate packaging Python projects, where packaging includes:
- Python package and module definitions
- Distribution package metadata
- Test hooks
- Project installation
- Platform-specific details
- Python 3 support
2023-01-15T01:52:47-08:00 sysutils/touchegg Multi-touch gesture recognizer
Touchegg is an app that runs in the background and transform the gestures you
make on your touchpad or touchscreen into visible actions in your desktop.
2023-01-14T23:37:15-08:00 audio/ggwave Tiny data-over-sound library
kbd-audio is a collection of command-line and GUI tools for capturing and
analyzing audio data.
2023-01-14T22:03:48-08:00 devel/imtui Immediate Mode Text-based User Interface C++ Library
ImTui is an immediate mode text-based user interface library. It supports
256 ANSI colors and mouse/keyboard input.
2023-01-14T18:00:55-08:00 misc/json-tui JSON terminal UI made in C++
json-tui is a JSON terminal UI made in C++.

Features:
* Interactive: Use keyboard or mouse to scroll/expand objects.
* Colors
* Responsive: Adapt to the terminal dimensions. Very long text values are
wrapped on several lines.
* Cross-platform
* The output is displayed inline with the previous commands. Meaning you can
still see the json after leaving json-tui.
* (Vim users): Also support j/k for navigation.
* Table view: Turn arrays of objects into tables.
2023-01-14T17:13:25-08:00 www/wasm-pack Workflow tool for Rust-generated WebAssembly
rust-wasm seeks to be a one-stop shop for building and working with rust-
generated WebAssembly that you would like to interop with JavaScript, in the
browser or with Node.js. `wasm-pack` helps you build rust-generated
WebAssembly packages that you could publish to the npm registry, or otherwise
use alongside any javascript packages in workflows that you already use, such
as webpack.
2023-01-13T10:23:35-07:00 devel/fsx File System eXerciser
File System eXerciser

The fsx utility tests file system I/O routines for correctness, with random
input. This is a Rust-based rewrite of the classic C utility, originally from
Apple Computer.
2023-01-14T13:10:38+01:00 www/qt6-webengine Qt 6 library to render web content
The Qt WebEngine module provides a web browser engine that makes it easy to
embed content from the World Wide Web into your Qt application on platforms
that do not have a native web engine.

Qt WebEngine provides C++ classes and QML types for rendering HTML, XHTML, and
SVG documents, styled using Cascading Style Sheets (CSS) and scripted with
JavaScript. HTML documents can be made fully editable by the user through the
use of the contenteditable attribute on HTML elements.
2023-01-13T17:41:00-08:00 math/the-algorithms-c++ Collection of various algorithms in mathematics, physics, etc
TheAlgorithms/C-Plus-Plus is a collection of open-source implementation of a
variety of algorithms implemented in C++ and licensed under MIT License.
These algorithms span a variety of topics from computer science, mathematics
and statistics, data science, machine learning, engineering, etc. The
implementations and the associated documentation are meant to provide a learning
resource for educators and students. Hence, one may find more than one
implementation for the same objective but using a different algorithm strategies
and optimizations.
2023-01-13T17:07:09-08:00 databases/nanodbc Small C++ wrapper for the native C ODBC API
nanodbc is a small library that makes ODBC API programming easy and fun again.
2023-01-13T20:26:55+00:00 net-mgmt/p5-Nagios-Plugin_check_raid Nagios/Icinga/Sensu plugin to check RAID status
Nagios/Icinga/Sensu plugin to check current server's RAID status

This plugin checks all RAID volumes (hardware and software) that can be
identified.

While written originally for Nagios, it's known to work also with:

* Icinga
* Sensu

This is supposed to be a general plugin to run via NRPE. It checks for the
various RAID systems, and verifies they are working correctly.

Some checks require root permission, that is acomplished using sudo.
Neccessary sudo rules (detected for your system), can be installed when
check_raid is invoked with -S argument. You need to be root user and it will add
required lines to the sudo config file. Run with -d to preview the sudo rules
2023-01-14T02:56:36+09:00 devel/heirloom-devtools OpenSolaris yacc, lex, m4, make, and SCCS
The Heirloom Development Tools package provides yacc, lex, m4, make,
and SCCS as portable derivatives of the utilities released by Sun
as part of OpenSolaris. The OpenSolaris utilities were in turn
derived from the original Unix versions, and are assumed be conforming
implementations of the POSIX standard.
2023-01-11T10:33:43-06:00 sysutils/pcns PowerChute Network Shutdown
PowerChute Network Shutdown (PowerChute) works in conjunction with the UPS
Network Management Card (NMC) to provide network-based shutdown of multiple
computer systems.

In the case of a UPS critical event, the software performs a graceful,
unattended system shutdown before the UPS battery is exhausted. The number of
protected systems is limited only by the capacity of the UPS.
2023-01-12T14:29:09+01:00 devel/py-pytoolconfig Python Tool Configuration
The goal of this project is to manage configuration for python tools,
such as black and rope and add support for a pyproject.toml
configuration file.
2023-01-11T23:20:48-08:00 misc/py-lightgbm Gradient boosting framework that uses tree based learning algorithms
LightGBM is a gradient boosting framework that uses tree based learning
algorithms. It is designed to be distributed and efficient with the
following advantages:
* Faster training speed and higher efficiency.
* Lower memory usage.
* Better accuracy.
* Support of parallel, distributed, and GPU learning.
* Capable of handling large-scale data.
2023-01-11T22:19:28-08:00 misc/lightgbm Gradient boosting framework that uses tree based learning algorithms
LightGBM is a gradient boosting framework that uses tree based learning
algorithms. It is designed to be distributed and efficient with the
following advantages:
* Faster training speed and higher efficiency.
* Lower memory usage.
* Better accuracy.
* Support of parallel, distributed, and GPU learning.
* Capable of handling large-scale data.
2023-01-11T21:24:48-08:00 math/py-annoy Approximate Nearest Neighbors in C++
Annoy (Approximate Nearest Neighbors Oh Yeah) is a C++ library with Python
bindings to search for points in space that are close to a given query point.
It also creates large read-only file-based data structures that are mmapped
into memory so that many processes may share the same data.
2023-01-11T21:23:33-08:00 math/annoy Approximate Nearest Neighbors in C++
Annoy (Approximate Nearest Neighbors Oh Yeah) is a C++ library with Python
bindings to search for points in space that are close to a given query point.
It also creates large read-only file-based data structures that are mmapped
into memory so that many processes may share the same data.
2023-01-11T18:02:04-08:00 devel/py-spyder-unittest Plugin to run tests from within the Spyder IDE
Spyder-unittest is a plugin that integrates popular unit test frameworks with
Spyder, allowing you to run test suites and view the results in the IDE.

The plugin supports the unittest module in the Python standard library as well
as the pytest and nose testing frameworks. Support for pytest is most complete
at the moment.
2023-01-11T17:47:02-06:00 biology/atac-seq Metaport for ATAC-Seq analysis
Metaport to install tools for typical ATAC-Seq analysis, including QC,
adapter trimming, alignment, and differential analysis.
2023-01-11T22:01:21+00:00 net/lavinmq Next-generation AMQP 0.9.1 based message broker
LavinMQ is a message queue server, also called a message broker, compatible
with the AMQP0.9 spec, where messages are published by a sending service called
a producer, via the broker, to then be consumed by the receiving service called
a consumer. When not handling messages, the queue can route, buffer, and
persist the messages according to rules set up by the user.

Messages can be sent across languages, platforms, and OS, which decouple
processes and creates a highly scalable system. lavinmq, as queue management
software, gives an organized, safe place for messages to wait until another
application or part of the system can come along and consume them for
processing.

lavinmq is written in Crystal, a statically compiled LLVM-based
language with a ruby-like syntax.

WWW: https://www.lavinmq.com/
2023-01-11T22:02:51+01:00 dns/letsdns Manage DANE TLSA records in DNS servers
LetsDNS

Manage DANE TLSA records in DNS servers. Supports multiple domains with multiple
TLS certificates each. LetsDNS can be invoked manually, from cron jobs, or
called in hook functions of ACME-clients like dehydrated or certbot.
2023-01-11T21:52:22+01:00 security/py-badkeys Tool to check public keys for known vulnerabilities
Tool and library to check cryptographic public keys for known vulnerabilities.

badkeys can directly scan SSH and TLS hosts and automatically check their
public keys.

This work was funded in part by Industriens Fond through the CIDI project
(Cybersecure IOT in Danish Industry) and in part by the Center for Information
Security and Trust (CISAT) at the IT University of Copenhagen, Denmark.
2023-01-11T07:44:11-08:00 devel/hotspot Perf GUI for performance analysis (needs mock 'perf' command)
The hotspot project is an effort to create a standalone GUI for performance
data. The first goal is to provide a UI like KCachegrind around Linux perf.
In the future various other performance data formats are planned to be
supported.
2023-01-11T01:30:36-08:00 x11-toolkits/kddockwidgets KDAB's Dock Widget Framework for Qt
KDDockWidgets is a Qt dock widget library written by KDAB, suitable for
replacing QDockWidget and implementing advanced functionalities missing
in Qt.

Although KDDockWidgets is ready to be used out of the box, it can also
be seen as a framework to allow building very tailored custom docking systems.
It tries to expose every internal widget and every knob for the app developer
to tune.
2023-01-10T08:03:17-08:00 devel/rustc-demangle Library for Rust symbol demangling
Library that demangles for Rust symbols.

The library is written in Rust.
This port has it's C/C++ API.
2023-01-10T08:03:17-08:00 net/ecal Enhanced Communication Abstraction Layer
The enhanced Communication Abstraction Layer (eCAL) is a middleware that enables
scalable, high performance interprocess communication on a single computer node
or between different nodes in a computer network. eCAL uses a publish-subscribe
pattern to automatically connect different nodes in the network.

eCAL automatically chooses the best available data transport mechanism for each
link:
* Shared memory for local communication (incredible fast!)
* UDP for network communication
2023-01-10T01:41:38-08:00 devel/recycle Simple resource pool for recycling resources in C++
recycle is an implementation of a simple C++ resource pool.
2023-01-10T14:42:52+01:00 security/keysmith Application to generate two-factor authentication tokens
Keysmith is an application to generate two-factor authentication (2FA) tokens
when logging in to your (online) accounts. Currently it supports both HOTP and
TOTP tokens.
2023-01-10T00:34:47-08:00 devel/ftxui C++ Functional Terminal User Interface library
FTXUI is a simple C++ library for terminal based user interfaces.

Feature:
* Functional style. Inspired by [1] and React
* Simple and elegant syntax (in my opinion)
* Keyboard & mouse navigation.
* Support for UTF8 and fullwidth chars
* Support for animations. Demo 1, Demo 2
* Support for drawing. Demo
* No dependencies
* Cross platform: Linux/MacOS (main target), WebAssembly, Windows
* Learn by examples, and tutorials
* Multiple packages: CMake FetchContent (preferred), vcpkg, pkgbuild, conan.
* Good practises: documentation, tests, fuzzers, performance tests, automated
CI, automated packaging, etc
2023-01-09T02:14:28-08:00 net/nebula Scalable overlay networking tool
Nebula is a scalable overlay networking tool with a focus on performance,
simplicity and security. It lets you seamlessly connect computers anywhere
in the world. Nebula is portable, and runs on Linux, OSX, Windows, iOS, and
Android. It can be used to connect a small number of computers, but is also
able to connect tens of thousands of computers.

Nebula incorporates a number of existing concepts like encryption, security
groups, certificates, and tunneling, and each of those individual pieces
existed before Nebula in various forms. What makes Nebula different to existing
offerings is that it brings all of these ideas together, resulting in a sum that
is greater than its individual parts.
2023-01-09T01:58:16-08:00 net/shadowsocks-rust Rust port of shadowsocks
shadowsocks-rust is a Rust port of shadowsocks.

shadowsocks is a fast tunnel proxy that helps you bypass firewalls.
2023-01-09T01:36:33-08:00 devel/py-xarray-simlab Xarray extension and framework for computer model simulations
xarray-simlab is a Python library that provides both a generic framework for
building computational models in a modular fashion and a xarray extension for
setting and running simulations using the xarray's Dataset structure. It is
designed for fast, interactive and exploratory modeling.

xarray-simlab is well integrated with other libraries of the PyData ecosystem
such as dask and zarr.
2023-01-09T01:08:47-08:00 devel/py-zarr Implementation of chunked, compressed, N-dimensional arrays for Python
Zarr is a Python package providing an implementation of compressed, chunked,
N-dimensional arrays, designed for use in parallel computing.
2023-01-09T00:49:06-08:00 misc/py-numcodecs Package providing buffer compression and transformation codecs for use
Numcodecs is a Python package providing buffer compression and transformation
codecs for use in data storage and communication applications.
2023-01-08T23:52:11-08:00 graphics/resvg-capi SVG rendering library (C++/Qt API)
resvg is an SVG rendering library.

It can be used as a Rust library, as a C library, and as a CLI
application to render static SVG files.

The core idea is to make a fast, small, portable SVG library with the goal to
support the whole SVG spec.

Features:
* Designed for edge-cases
* Safety
* Zero bloat
* Portable
* SVG preprocessing
* Performance
* Reproducibility
2023-01-08T23:23:21-08:00 devel/cargo-bloat Find out what takes most of the space in your executable
cargo-bloat allows you to find out what takes most of the space in
your executable.
2023-01-05T23:10:00+00:00 audio/d11amp Oldskool MP3 player
D11AMP is an oldskool MP3 player. In addition to being a frontend
to mpg123, it can handle WinAMP's treasure trove of skins.
2023-01-06T17:02:58+01:00 devel/exomizer Cruncher for 6502-based systems
Exomizer is a program that compresses files in a way that tries to be as
efficient as possible but still allows them to be decompressed in environments
where CPU speed and RAM are limited. For some popular 8-bit computers using
6502 compatible CPUs it can also generate executable files that decompress
themselves in memory when run.

Exomizer operates in two major modes. It has a raw mode that compresses plain
files and produces plain files. This mode is used by the raw subcommand. All
other subcommands use the second mode. It requires all source files to be
targeted to be decrunched at specific addresses in the 16-bit address space of
the target computer. In this mode, no file can be larger than 64kB since all
data must be addressable using 16-bits. The targeted mode has the following
features:
* It reads plain or .prg files to any given address.
* It can produce stand-alone self-decrunching files for the following targets:
- Commodore VIC20, C64, C65, C16/plus4, C128 and PET 4032
- Atari 400/800 XL/XE
- Apple ][+ and //e
- Oric-1 and Oric Atmos
- BBC Micro B
* It can produce files for both "in memory" and "from disk" decrunching.
* It handles RLE-sequences well, no packer is necessary.
* It is able to link/combine more than one source file into the same crunched
target file.
2023-01-08T19:23:48-08:00 misc/py-ipyfastscape Interactive widgets for topographic data analysis and modelling
Ipyfastscape is interactive widgets for topographic data analysis and modelling
in Jupyter notebooks.

While ipyfastscape is tightly integrated with fastscape, it also integrates very
well with any data in the form of an xarray dataset or any model created with
xarray-simlab.

The widgets available here are built on top of libraries of the jupyter's widget
ecosystem such as ipywidgets and ipygany. You can reuse those high-level UI
components as-is within notebooks (embedded mini-apps) or for building
interactive dashboards that you can then publish as standalone web applications.
2023-01-08T19:05:35-08:00 science/py-ipygany 3-D scientific visualization in Jupyter Notebooks
ipygany is a Jupyter Interactive Widgets library for 3-D mesh analysis.

Features:
ipygany has many features including:
* VTK loader for displaying your computation results in the Jupyter Notebook
* Structured and Unstructured grids support
* 2-D cell based meshes support (quads, triangles...) as well as 3-D cell based
meshes support (tetrahedrons, quadratic tetrahedrons...)
* Animations
* IsoColor effect
* Warp effect
* IsoSurface computation
* Threshold effect (for visualizing only the parts that are inside of a range
of data)
* Point cloud visualization
* Water effect, for nice water visualization with real-time caustics
2023-01-08T18:56:02-08:00 devel/py-ipydatawidgets Set of widgets to facilitate reuse of large datasets across widgets
ipydatawidgets is a set of widgets to help facilitate reuse of large datasets
across different widgets, and different packages.
2023-01-09T11:19:20+08:00 security/lua-argon2 Lua C binding for the Argon2 password hashing function
Lua C binding for the Argon2 password hashing function. Compatible with Lua 5.x
and LuaJIT.
2023-01-08T16:09:29-08:00 devel/py-traittypes Traitlets types for NumPy, SciPy and friends
The traittypes package provides a reference implementation of trait types for
common data structures used in the scipy stack such as
* numpy arrays
* pandas and xarray data structures
which are out of the scope of the main traitlets project but are a common
requirement to build applications with traitlets in combination with the scipy
stack.
2023-01-08T15:43:42-08:00 misc/py-fastscapelib Library of efficient algorithms for topographic data
py-fastscapelib is a python binding of fastscapelib, a C++ library of efficient
algorithms for processing topographic data and landscape evolution modeling.
2023-01-08T15:35:50-08:00 misc/fastscapelib Library of efficient algorithms for topographic data
fastscapelib is a C++ library of efficient algorithms for processing topographic
data and landscape evolution modeling.

This library currently has Python bindings and is easily extensible to other
languages.
2023-01-08T16:18:53-08:00 databases/qdrant Vector search engine and database for the next gen AI applications
Qdrant is a vector similarity search engine and vector database.

It provides a production-ready service with a convenient API to store,
search, and manage points - vectors with an additional payload.
Qdrant is tailored to extended filtering support. It makes it useful for all
sorts of neural-network or semantic-based matching, faceted search, and other
applications.

With Qdrant, embeddings or neural network encoders can be turned into
full-fledged applications for matching, searching, recommending, and much
more.
2023-01-08T14:02:16-08:00 www/microbin Tiny, self-contained, configurable paste bin and URL shortener
MicroBin is a super tiny, feature rich, configurable, self-contained and
self-hosted paste bin web application. It is very easy to set up and use, and
will only require a few megabytes of memory and disk storage.
It takes only a couple minutes to set it up.
2023-01-08T13:53:39-08:00 devel/git-branchless High-velocity, monorepo-scale workflow for Git
`git-branchless` is a suite of tools which enhances Git in several ways:
It makes Git easier to use, both for novices and for power users. Examples:
- `git undo`: a general-purpose undo command.
- The smartlog: a convenient visualization tool.
- `git restack`: to repair broken commit graphs.
- Speculative merges: to avoid being caught off-guard by merge conflicts.

It adds more flexibility for power users. Examples:
- Patch-stack workflows: strong support for "patch-stack" workflows as
used by the Linux and Git projects, as well as at many large tech companies.
(This is how Git was "meant" to be used.)
- Prototyping and experimenting workflows: strong support for prototyping and
experimental work via "divergent" development.
- `git sync`: to rebase all local commit stacks and branches without having
to check them out first.
- `git move`: The ability to move subtrees rather than "sticks" while cleaning
up old branches, not touching the working copy, etc.
- Anonymous branching: reduces the overhead of branching for experimental
work.
- In-memory operations: to modify the commit graph without having to check out
the commits in question.
- `git next/prev`: to quickly jump between commits and branches in a commit
stack.
- `git co -i/--interactive`: to interactively select a commit to check out.
2023-01-08T11:08:37-08:00 editors/languageclient-neovim Language Server Protocol (LSP) support for vim and neovim
Language Server Protocol (LSP) support for vim and neovim.

Features:
* Non-blocking asynchronous calls.
* Sensible completion
Integrated well with deoplete or ncm2, or MUcomplete.
Or simply with vim built-in `omnifunc`.
* Realtime diagnostics/compiler/lint message.
* Rename.
* Hover/Get identifier info.
* Goto definition.
* Goto reference locations.
* Workspace/Document symbols query
* Formatting
* Code Action/Quick Fix
2023-01-08T03:40:28-08:00 devel/git-cliff Highly customizable changelog generator
git-cliff can generate changelog files from the Git history by utilizing
conventional commits as well as regex-powered custom parsers.
The changelog template can be customized with a configuration file
to match the desired format.
2023-01-08T02:51:08-08:00 devel/git-workspace Sync personal and work git repositories from multiple providers
If your company has a large number of repositories and your work involves
jumping between a lot of them then `git-workspace` can save you some time by:
* Easily synchronizing your projects directory with Github, Gitlab.com or
Gitlab self-hosted.
* Keep projects consistently named and under the correct path.
* Automatically set upstreams for forks.
* Move deleted repositories to an archive directory.
* Allowing you to access any repository instantly.
* Execute `git fetch` on all projects in parallel.
2023-01-08T02:32:47-08:00 textproc/hq jq, but for HTML
jq, but for HTML.

`hq` reads HTML and converts it into a JSON object based on a series of CSS
selectors. The selectors are expressed in a similar way to JSON, but where the
values are CSS selectors.
2023-01-08T02:25:07-08:00 net/rathole Lightweight and high-performance reverse proxy for NAT traversal
rathole is a high-performance reverse proxy for NAT traversal.

Features:
* High Performance: much higher throughput can be achieved than frp, and more
stable when handling a large volume of connections.
* Low Resource Consumption: Consumes much fewer memory than similar tools.
* Security: Tokens of services are mandatory and service-wise. The server and
clients are responsible for their own configs. With the optional Noise
Protocol, encryption can be configured at ease. No need to create a
self-signed certificate. TLS is also supported.
* Hot Reload: Services can be added or removed dynamically by hot-reloading the
configuration file. HTTP API is WIP.
2023-01-08T01:40:18-08:00 cad/silice Language that simplifies prototyping and writing algorithms for FPGAs
Yosys is a framework for Verilog RTL synthesis. It currently has
extensive Verilog-2005 support and provides a basic set of synthesis
algorithms for various application domains.
2023-01-08T00:52:49-08:00 cad/py-edalize Library for interfacing EDA tools
Edalize is an award winning Python library for interacting with EDA tools.
It can create project files for supported tools and run them in batch or
GUI mode (where supported).
2023-01-08T00:47:46-08:00 cad/py-vunit-hdl Open source unit testing framework for VHDL/SystemVerilog
VUnit is an open source unit testing framework for VHDL/SystemVerilog. It
features the functionality needed to realize continuous and automated
testing of your HDL code. VUnit doesn't replace but rather complements
traditional testing methodologies by supporting a test early and often
approach through automation. Read more about VUnit.
2023-01-08T00:46:21-08:00 comms/sigdigger Qt-based digital signal analyzer
SigDigger is a free digital signal analyzer for GNU/Linux and macOS, designed
to extract information of unknown radio signals. It supports a variety of SDR
devices through SoapySDR, and allows adjustable demodulation of FSK, PSK and
ASK signals, decode analog video, analyze bursty signals and listen to analog
voice channels (all in real time).
2023-01-07T12:17:59-08:00 comms/suwidgets Sigutils-related widgets
Sigutils-related widgets that are used in SigDigger.
2023-01-07T11:11:33-08:00 comms/suscan Channel scanner based on sigutils library
Suscan is a realtime DSP processing library. It provides a set of useful
abstractions to perform dynamic digital signal analysis and demodulation.

Suscan offers features like:
* Multicore-friendly signal processing, based on worker threads
* Generic ASK, FSK, PSK and audio demodulators
* An extensible codec interface
* Configuration file API (XML)
* Source API based on SoapySDR
2023-01-07T00:59:34-08:00 comms/sigutils Small signal processing utility library
The sigutils library is a digital signal processing library written in C,
designed for blind signal analysis and automatic demodulation.
2023-01-06T23:10:13-08:00 editors/ox Independent Rust text editor that runs in your terminal
Ox is a code editor. It was written in Rust using ANSI escape sequences.
It assists developers with programming by providing several tools to speed up
and make programming easier and a refreshing alternative to heavily bloated
and resource hungry editors such as VS Code and JetBrains. Ox is lightweight
so it can be used on older computers.
2023-01-06T22:56:15-08:00 graphics/resvg SVG rendering library
resvg is an SVG rendering library.

It can be used as a Rust library, as a C library, and as a CLI
application to render static SVG files.

The core idea is to make a fast, small, portable SVG library with the goal to
support the whole SVG spec.

Features:
* Designed for edge-cases
* Safety
* Zero bloat
* Portable
* SVG preprocessing
* Performance
* Reproducibility
2023-01-06T19:13:04-08:00 misc/py-shap2 Unified approach to explain the output of any machine learning model
SHAP (SHapley Additive exPlanations) is a game theoretic approach to explain
the output of any machine learning model. It connects optimal credit
allocation with local explanations using the classic Shapley values from game
theory and their related extensions.
2023-01-06T07:31:22-08:00 x11/xdg-desktop-portal-gtk Gtk implementation of xdg-desktop-portal
xdg-desktop-portal-gtk is a backend implementation for xdg-desktop-portal that
is using GTK and various pieces of GNOME infrastructure, such as
the org.gnome.Shell.Screenshot or org.gnome.SessionManager D-Bus interfaces.
2023-01-06T07:31:22-08:00 graphics/bgfx Cross-platform, graphics API agnostic rendering library
Cross-platform, graphics API agnostic, "Bring Your Own Engine/Framework" style
rendering library.
2023-01-06T07:31:22-08:00 x11-toolkits/imgui Bloat-free Graphical User interface for C++ with minimal dependencies
Dear ImGui is a bloat-free graphical user interface library for C++. It outputs
optimized vertex buffers that you can render anytime in your 3D-pipeline-enabled
application. It is fast, portable, renderer agnostic, and self-contained
(no external dependencies).

Dear ImGui is designed to enable fast iterations and to empower programmers to
create content creation tools and visualization / debug tools (as opposed to UI
for the average end-user). It favors simplicity and productivity toward this
goal and lacks certain features commonly found in more high-level libraries.

Dear ImGui is particularly suited to integration in game engines (for tooling),
real-time 3D applications, fullscreen applications, embedded applications, or
any applications on console platforms where operating system features are
non-standard.
2023-01-06T07:31:22-08:00 sysutils/genimage Tool to generate multiple filesystem and flash images from a tree
genimage is a tool to generate multiple filesystem and flash/disk images
from a given root filesystem tree. genimage is intended to be run in a
fakeroot environment. It also supports creating flash/disk images out of
different file-system images and files.

Configuration is done in a config file parsed by libconfuse. Options like the
path to tools can be given via environment variables, the config file or from
commandline switches.
2023-01-06T07:31:22-08:00 devel/fnm Fast and simple Node.js version manager, built in Rust
fnm is a fast and simple Node.js version manager, built in Rust.

Features:
* Cross-platform support
* Single file, easy installation, instant startup
* Built with speed in mind
* Works with `.node-version` and `.nvmrc` files
2023-01-06T07:31:22-08:00 devel/gitoxide Idiomatic, lean, fast & safe pure Rust implementation of Git
`gitoxide` is an implementation of `git` written in Rust for developing
future-proof applications which strive for correctness and performance while
providing a pleasant and unsurprising developer experience.

`gitoxide` provides the `gix` and `ein` binaries for use on the command-line
to allow experimentation with key features like `fetch` and `clone`, and to
validate the usability and control of the API.

`gitoxide` aspires to be a production-grade server implementation and the
`ein` binary aspires to become the default way to interact with git
repositories.
2023-01-06T12:09:13+00:00 security/opie One-time Passwords In Everything
Provides utilities and PAM modules for OPIE one-time passwords.
2023-01-06T00:59:37-08:00 shells/shell-hist Inspect your shell history
shell-hist allows to take a look at your most common shell commands, based on
your history file.
2023-01-06T00:58:27-08:00 misc/silicon Create beautiful image of your source code
Silicon can render your source code into a beautiful image.

Silocon works without browser & Internet.
It renders your source code very fast, on the fly.
2023-01-05T23:38:36-08:00 deskutils/skim Fuzzy finder
skim is is a general fuzzy finder that saves time.

skim provides a single executable: `sk`. Anywhere who would want to use
`grep` should try `sk` instead.
2023-01-05T23:16:54-08:00 misc/star-history Graph history of GitHub stars of a user or repo over time
star-history is a command line program to generate a graph showing number of
GitHub stars of a user, org or repo over time.

star-history requires a token for accessing GitHub's GraphQL API. Head to go to
https://github.com/settings/tokens and click "Generate new token". The default
public access permission is sufficient - you can leave all the checkboxes
empty. Save the generated token somewhere like ~/.githubtoken.
2023-01-05T22:48:11-08:00 sysutils/szyszka Szyszka is fast and powerful file renamer
Szyszka is a simple but powerful and fast bulk file renamer.

Features:
- Written in Rust
- Simple GUI created using GTK3
- Multiple rules which can be freely combined:
- Replace text
- Trim text
- Add text
- Add numbers
- Purge text
- Change letters to upper-/lowercase
- Custom rules
- Ability to edit, reorder rules and results
- Handle even hundreds thousands of records
2023-01-05T22:29:21-08:00 devel/tagref Tagref helps you maintain cross-references in your code
tagref helps to maintain code references in codebases.

Tagref ensures such references remain valid. If someone tries to delete or
rename the tag, Tagref will complain. More precisely, it checks the following:
1. References actually point to tags. A tag cannot be deleted or renamed
without updating the references that point to it.
2. Tags are distinct. There is never any ambiguity about which tag is being
referenced.
2023-01-05T20:52:07-08:00 sysutils/tere Terminal file explorer
`tere` is a terminal file explorer. It is a faster alternative to using `cd`
and `ls` to browse folders in your terminal. `tere` only really does one thing:
it provides a TUI for efficiently navigating to a folder, and then prints the
path to that folder when you exit. By configuring your shell to `cd` to the
printed folder, you can move around in your filesystem very quickly.
2023-01-05T19:09:25-08:00 devel/parol-ls Language server for Parol, a LL(k) parser generator
Language server for parol, a LL(k) parser generator for Rust.

It can be used with software that supports language server
protocol.
2023-01-05T18:52:27-08:00 devel/parol LL(k) parser generator for Rust
parol is a LL(k) parser generator for Rust.

It's an installable command line tool that can generate complete parsers from
a single grammar description file including all AST data types you would
otherwise had to design by yourself. `parol` does this solely by analyzing your
language's grammar.

You can control the process of AST type generation. First you can mark elements
for omission in your AST. Also you can specify your own types for language
elements.

Language description and language implementation is strictly separated in
`parol`. Thus you can design your language's grammar without any need to process
anything because generated parsers function by default as acceptors. This
empowers you to do a real rapid prototyping of your grammar.
2023-01-05T18:58:34-08:00 sysutils/ddh Fast duplicate file finder
DDH traverses input directories and their subdirectories.
It also hashes files as needed and reports findings.

The H in "hTool" is silent. The H in its abbreviation, "DDH," is not.

This tool is called DDH for two very good reasons.
* DDT is a dangerous pesticide
* I mistyped when I created the project
2023-01-05T18:07:52-08:00 devel/amber Code search/replace tool
amber is a code search and replace tool written in Rust.
This tool is inspired by 'ack', 'ag', and other grep-like tools.

Features:
- Recursively search from the current directory
- Ignore VCS directories (.git, .hg, .svn, .bzr)
- Ignore binary files
- Output by the colored format

Large files (> 1MB by default) are divided and searched in parallel.

amber can replace a keyword over directories (traditionally by
`find ... | xargs sed -i '...'`) .
User can decide to do replacing or not interactively.
2023-01-05T17:58:13-08:00 cad/veryl Veryl: A modern Hardware Description Language (HDL)
Veryl is a modern hardware description language.

This project is under the exploration phase of language design.

Features:

* Symplified syntax
* Based on SystemVerilog / Rust
* Transpiler to SystemVerilog
* Human readable output
* Interoperability with SystemVerilog
* Integrated Tools
* Semantic checker
* Source code formatter
* Language server
2023-01-05T17:27:10-08:00 cad/svls SystemVerilog language server
svls is a SystemVerilog language server.

Feature:
* Linter based on svlint
2023-01-05T02:46:41-08:00 devel/tree-sitter-graph Construct graphs from parsed source code
The `tree-sitter-graph` library and app defines a DSL for constructing arbitrary
graph structures from source code that has been parsed using tree-sitter.
2023-01-04T21:58:44-08:00 misc/pqrs Command line tool for inspecting Apache Parquet files
pqrs is a command line tool for inspecting Parquet files.
It is a replacement for the parquet-tools utility written in Rust.
2023-01-04T21:49:48-08:00 devel/dura Background process that watches Git repositories and backs up data
Dura is a background process that watches your Git repositories and commits
your uncommitted changes without impacting HEAD, the current branch, or the
Git index (staged files). If you ever get into an "oh snap!" situation where
you think you just lost days of work, checkout a `dura` branch and recover.

Without `dura`, you use Ctrl-Z in your editor to get back to a good state.
That's so 2021. Computers crash and Ctrl-Z only works on files independently.
Dura snapshots changes across the entire repository as-you-go, so you can
revert to "4 hours ago" instead of "hit Ctrl-Z like 40 times or whatever".
2023-01-04T21:40:53-08:00 devel/patsh Command-line tool for patching shell scripts inspired by resholve
patsh is a command-line tool for patching shell scripts inspired by resholve.
2023-01-04T21:36:00-08:00 security/diswall Distributed firewall
Diswall (distributed firewall) - a client of distributed firewall working on
many servers and using NATS for the transport level.
Its purpose - blocking IPs with a blink of the eye on all servers in any
infrastructure when some IP checks any of the closed ports of anyone of these
servers. Therefore, diswall provides good protection of whole infrastructure
(as anti-shodan) preventing intruder to get any system information.
2023-01-04T21:28:43-08:00 misc/zine Simple and opinionated tool to build your own magazine
Zine is a simple and opinionated tool to build your own magazine.

Features:
- Mobile-first.
- Intuitive and elegant magazine design.
- Best reading experiences.
- Theme customizable, extend friendly.
- RSS Feed supported.
- Open Graph Protocol supported.
- Article topic supported.
- I18n and l10n supported.
- Build into a static website, hosting anywhere.
2023-01-04T21:09:46-08:00 deskutils/thokr Sleek typing tui with visualized results and historical logging
thokr is sleek typing TUI with visualized results and historical logging.
2023-01-04T21:01:32-08:00 misc/rsclock Simple terminal clock written in Rust
rsClock is a simple terminal clock.
2023-01-04T20:54:23-08:00 sysutils/process-viewer Process viewer GUI in Rust
process-viewer is a process viewer GUI in Rust. It provides current status of
your processes (cpu and memory usage) and your system (usage of every core and
of your RAM, and the temperature of your components if this information is
available).
2023-01-04T17:34:58-08:00 misc/lscolors Tool to colorize paths using LS_COLORS
lscolors is a tool and a library for colorizing paths according to
the `LS_COLORS` environment variable.
2023-01-04T17:33:44-08:00 deskutils/jot Rapid note management for the terminal
Jot is a feature-stripped version of Obsidian focused on rapid note management
through the terminal.
It uses the same format of storage as Obsidian, i.e. markdown files for notes,
and local folders for vaults (and sub-folders).
Commands that encompass all basic needs are included. Each command has an alias
(two letter abbreviation) to further increase rapidity.
2023-01-05T04:57:22+08:00 textproc/fcitx5-m17n Multilingualization support for Fcitx5
The libm17n, a multilingual input method engine, backend of the Fcitx5 IM
framework.
2023-01-04T14:17:01+01:00 multimedia/uxplay AirPlay Unix mirroring server
UxPlay is an AirPlay2 Mirror server. Its main use is to act like an
AppleTV for screen-mirroring (with audio) of iOS/iPadOS/macOS clients
(iPhone, iPod Touch, iPad, Mac computers) in a window on the server
display (with the possibility of sharing that window on screen-sharing
applications such as Zoom). UxPlay supports Apple's AirPlay2 protocol
using "Legacy Pairing".

The UxPlay server and its client must be on the same local area network,
on which a Bonjour/Zeroconf mDNS/DNS-SD server is also running (only
DNS-SD "Service Discovery" service is strictly necessary, it is not
necessary that the local network also be of the ".local" mDNS-based
type). This is usually provided by Avahi, through the avahi-daemon
service.
2023-01-04T03:27:14-08:00 math/cvc5 Automatic theorem prover for SMT (Satisfiability Modulo Theories)
An efficient open-source automatic theorem prover for satisfiability modulo
theories (SMT) problems. It can be used to prove the validity (or, dually, the
satisfiability) of first-order formulas in a large number of built-in logical
theories and their combination.
2023-01-04T00:29:55-08:00 math/symfpu Implementation of IEEE-754 / SMT-LIB floating-point
SymFPU is an implementation of the SMT-LIB / IEEE-754 operations in terms of
bit-vector operations. It is templated in terms of the bit-vectors,
propositions, floating-point formats and rounding mode types used. This allow
the same code to be executed as an arbitrary precision "SoftFloat" library
(although it's performance would not be good) or to be used to build symbolic
representation of floating-point operations suitable for use in "bit-blasting"
SMT solvers (you could also generate circuits from them but again, performance
will likely not be good).
2023-01-03T07:39:38-08:00 math/lingeling Lingeling SAT Solver
Lingeling, Plingeling and Treengeling.

The parallel portfolio front-end Plingeling was ranked on the first place on
unsatisfiable instances in the parallel track of the SAT Competition 2020, and
second place overall in the parallel track.
2023-01-04T06:34:51+09:00 www/p5-Mojolicious-Plugin-OpenAPI OpenAPI / Swagger plugin for Mojolicious
Mojolicious::Plugin::OpenAPI is Mojolicious::Plugin that add
routes and input/output validation to your Mojolicious application
based on a OpenAPI (Swagger) specification. This plugin supports
both version 2.0 and 3.x, though 3.x might have some missing features.
2023-01-04T06:32:08+09:00 www/p5-OpenAPI-Client Client for talking to an OpenAPI-powered server
OpenAPI::Client can generate classes that can talk to an Open API
server. This is done by generating a custom class, based on a Open API
specification, with methods that transform parameters into a HTTP request.

The generated class will perform input validation, so invalid data
won't be sent to the server.
2023-01-03T17:31:33+00:00 sysutils/poweralertd UPower-powered power alerter
Gives you power notifications as you need them. Just run it.

Depends on UPower and a notification daemon such as mako.
2023-01-03T07:39:38-08:00 misc/amazon-qldb-shell QLDB interactive shell to interact with Amazon Quantum Ledger Database
amazon-qldb-shell provides an interface to send PartiQL statements to
Amazon Quantum Ledger Database (QLDB).

This tool is not intended to be incorporated into an application or adopted
for production purposes.

The objective of the tool is to give developers, devops, database
administrators, and anyone else interested the opportunity for rapid
experimentation with QLDB and PartiQL.
2023-01-03T08:51:26-08:00 lang/frawk Efficient awk-like language
frawk is a small programming language for writing short programs processing
textual data. To a first approximation, it is an implementation of the
AWK language; many common Awk programs produce equivalent output when passed
to frawk. You might be interested in frawk if you want your scripts to handle
escaped CSV/TSV like standard Awk fields, or if you want your scripts to
execute faster.
2023-01-03T01:04:36-08:00 shells/nushell New type of shell
A new type of shell.

Nu draws inspiration from projects like PowerShell, functional programming
languages, and modern CLI tools. Rather than thinking of files and data as
raw streams of text, Nu looks at each input as something with structure.
For example, when you list the contents of a directory what you get back is
a table of rows, where each row represents an item in that directory.
These values can be piped through a series of steps, in a series of commands
called a 'pipeline'.
2023-01-02T22:33:46-08:00 devel/glitter Tool for generating and structuring Git commit messages
Glitter is a tool for generating and structuring commit messages via arguments
passed to the tool. It allows you to configure it extensively and easily.

Features:
- Config files
- Simple errors
- Glitter Hooks (Git hooks natively built into Glitter)
2023-01-02T22:10:23-08:00 x11/clipcat Clipcat is a clipboard manager written in Rust
Clipcat is a clipboard manager written in Rust Programming Language.

Clipcat uses the Client-Server architecture. There are two role types in this
architecture: `Server` and `Client`.

A `clipcat` server (as known as daemon) is running as the background process
and does the following routines:
- Watching the changes of `X11 clipboard`.
- Caching the content of `X11 clipboard`.
- Inserting content into `X11 clipboard`.
- Serving as a `gRPC` server and waiting for remote procedure call from clients.

A `clipcat` client sends requests to the server for the following operations:
- List: list the cached clips from server.
- Insert: replace the current content of `X11 clipboard` with a clip.
- Remove: remove the cached clips from server.
2023-01-02T19:49:01-08:00 www/cobalt Static site generator written in Rust
cobalt is a straightforward static site generator written in Rust.
2023-01-02T19:47:54-08:00 misc/binocle Graphical tool to visualize binary data
binocle is a graphical tool to visualize binary data.
It colorizes bytes according to different rules and renders them as pixels in
a rectangular grid.
This allows users to identify interesting parts in large files and to reveal
image-like regions.
2023-01-02T18:56:02-08:00 databases/quake Quake is a knowledge management meta-framework for geeks
Quake is a knowledge management meta-framework for geeks.
It can:
- freedom text content management. todo lists, article management, book reviews,
notes, etc.
- construct a knowledge network system. customized markdown link
- fleeting inspiration.support quick start (CLI, TUI, Web, GUI) and global
search
- freely present the canvas. DSL and free Sketchpad
- graph engine
2023-01-02T18:53:12-08:00 www/reddsaver CLI tool to download saved and upvoted media from Reddit
reddsaver is a command line tool to download saved/upvoted media from Reddit.

It supports:
- Reddit: PNG/JPG images, GIFs, Image galleries, videos
- Giphy: GIFs
- Imgur: Direct images and GIFVs
- Gfycat/Redgifs: GIFs

* GIF/GIFV from Imgur/Gfycat/Redgifs are downloaded as mp4
* Does *not* support downloading images from Imgur post links
2023-01-02T18:38:58-08:00 misc/arrow-datafusion Apache Arrow DataFusion SQL Query Engine
DataFusion is an extensible query planning, optimization, and execution
framework, written in Rust, that uses Apache Arrow as its in-memory format.

Features:
- SQL query planner with support for multiple SQL dialects
- DataFrame API
- Parquet, CSV, JSON, and Avro file formats are supported natively. Custom
file formats can be supported by implementing a `TableProvider` trait.
- Supports popular object stores, including AWS S3, Azure Blob
Storage, and Google Cloud Storage. There are extension points for implementing
custom object stores.

Use Cases:
DataFusion is modular in design with many extension points and can be
used without modification as an embedded query engine and can also provide
a foundation for building new systems. Here are some example use cases:
- DataFusion can be used as a SQL query planner and query optimizer, providing
optimized logical plans that can then be mapped to other execution engines.
- DataFusion is used to create modern, fast and efficient data
pipelines, ETL processes, and database systems, which need the
performance of Rust and Apache Arrow and want to provide their users
the convenience of an SQL interface or a DataFrame API.
2023-01-02T18:26:31-08:00 x11/rlaunch Fast, light-weight and modern application launcher for X11
rlaunch is a fast, light-weight and modern application launcher for X11 written
in Rust.

This should work on all linux distributions and DEs that use X11, but if it
doesn't - feel free to file an issue.
2023-01-02T18:08:31-08:00 www/stork Impossibly fast web search, made for static sites
Stork is a library for creating beautiful, fast, and accurate full-text search
interfaces on the web.

It comes in two parts. First, it's a command-line tool that indexes content and
creates a search index file that you can upload to a web server. Second, it's a
Javascript library that uses that index file to build an interactive search
interface that displays optimal search results immediately to your user, as they
type.

Stork is built with Rust, and the Javascript library uses WebAssembly behind the
scenes. It's easy to get started and is even easier to customize so it fits your
needs. It's perfect for Jamstack sites and personal blogs, but can be used
wherever you need an interactive search bar.
2023-01-02T17:18:08-08:00 devel/tarpaulin Code coverage tool for Rust projects
Tarpaulin is a code coverage reporting tool for the Cargo build system, named
for a waterproof cloth used to cover cargo on a ship. Currently, tarpaulin
provides working line coverage and while fairly reliable may still contain
minor inaccuracies in the results. A lot of work has been done to get it
working on a wide range of projects, but often unique combinations of packages
and build features can cause issues so please report anything
you find that's wrong. Also, check out our roadmap for planned features.
2023-01-02T16:33:56-08:00 misc/dotenv-linter Linter for .env files. Written in Rust
dotenv-linter is a lightning-fast linter for .env files written in Rust.

A .env file or 'dotenv' file is a simple text file containing all the
environment variables of a project.
2023-01-02T15:50:13-08:00 cad/svlint SystemVerilog linter
svlint is a SystemVerilog linter.

svlint uses supplied .svlint.toml to specify enabled rules.
Configuration file is searched to the upper directory until /.
2023-01-02T15:24:20-08:00 devel/argc Easily parse command line arguments in bash
argc allows to easily parse command line arguments in bash.

To write a command-line program with argc, we only need to do two things:
1. Describe options, flags, positional parameters and subcommands in comments.
2. Insert `eval $(argc "$0" "$@")` into script to let argc to parse command line
arguments.
2023-01-02T15:15:48-08:00 sysutils/async Tool to parallelize shell commands
async is a tool to run shell commands in parallel and is designed to be able to
quickly parallelize shell scripts with minimal changes.

It was inspired by GNU Parallel, with the main difference being that async
retains state between commands by running a server in the background.
2023-01-02T15:12:16-08:00 devel/bacon Background rust code check
bacon is a background rust code checker.

It's designed for minimal interaction so that you can just let it running,
side to your editor, and be notified of warnings and errors in your Rust code.
2023-01-02T15:02:16-08:00 textproc/biodiff Hex diff viewer using alignment algorithms from biology
biodiff is a tool for binary diffing.

The tool is able to show two binary files side by side so that similar places
will be at the same position on both sides and bytes missing from one side are
padded.

It uses bio-informatics algorithms from the rust-bio library, typically used
for DNA sequence alignment, for that.
The dialog boxes for configuration are done using the github.com/gyscos/cursive
library.
2023-01-02T14:35:32-08:00 devel/bunyan CLI to pretty print logs in bunyan format
bunyan-rs is a Rust port of (a subset of) the original NodeJS bunyan CLI.
2023-01-02T14:19:07-08:00 devel/cbfmt Tool to format codeblocks inside markdown and org documents
cbfmt is a tool to format codeblocks inside markdown, org, and restructured
text documents.
It iterates over all codeblocks, and formats them with the tool(s) specified
for the language of the block.
2023-01-02T16:46:57-05:00 graphics/R-cran-magick Advanced Graphics and Image-Processing in R
Advanced Graphics and Image-Processing in R
Bindings to ImageMagick. Supports many common formats and manipulations.
The package includes a native graphics device for creating in-memory
graphics or drawing onto images using pixel coordinates.
2023-01-02T11:41:06-08:00 devel/convco Conventional commit CLI
convco is a Conventional commit cli.

It provides the following commands:
* convco changelog: Create a changelog file.
* convco check: Checks if a range of commits is following the convention.
* convco commit: Helps to make conventional commits.
* convco version: Finds out the current or next version.
2023-01-02T02:11:00-08:00 devel/cocogitto Conventional commits toolbox
cocogitto is the Conventional Commits toolbox.

Features:
* Verified commits: create conventional compliant commits with ease.
* Automatic Version bump and changelog: automatically bump versions and generate
changelogs with your own custom steps and workflows.
* Release profiles: your branching model requires different steps for releases,
* Depends only on libgit2: cocogitto has one standalone binary, the only system
dependency is libgit2.
* Conventional git log: search your commit history matching Conventional Commits
items such as scope and commit type.
* GitHub integration: enforce the conventional commits specification with our
GitHub action and bot.
2023-01-02T01:38:25-08:00 databases/gobang Cross-platform TUI database management tool written in Rust
gobang is a cross-platform TUI database management tool written in Rust.

Features:
* Cross-platform support (macOS, Windows, Linux)
* Multiple Database support (MySQL, PostgreSQL, SQLite)
* Intuitive keyboard only control
2023-01-02T01:37:37-08:00 databases/movine Database migration manager written in Rust
Movine is a simple database migration manager that aims to be compatible with
real-world migration work. Many migration managers get confused with
complicated development strategies for migrations. Oftentimes migration managers
do not warn you if the SQL saved in git differs from what was actually run on
the database. Movine solves this issue by keeping track of the unique hashes for
the up.sql and down.sql for each migration, and provides tools for fixing
issues. This allows users to easily keep track of whether their local migration
history matches the one on the database.
2023-01-02T01:28:21-08:00 databases/replibyte Seed your databases with your production data
Replibyte is a blazingly fast tool to seed your databases with your production
data while keeping sensitive data safe.
2023-01-02T01:17:58-08:00 www/dot-http Text-based scriptable HTTP client
dot-http is a text-based scriptable HTTP client. It is a simple language that
resembles the actual HTTP protocol but with just a smidgen of magic to make it
more practical for someone who builds and tests APIs.
2023-01-02T01:11:04-08:00 databases/frece Maintain a database sorted by frecency (frequency + recency)
frece maintains databases sorted by frecency (frequency + recency).
2023-01-02T01:03:30-08:00 textproc/jaq jq clone focussed on correctness, speed, and simplicity
jaq is a clone of the JSON data processing tool jq. jaq aims to support
a large subset of jq's syntax and operations.

jaq focusses on three goals:
* Correctness
* Performance
* Simplicity
2023-01-02T00:44:16-08:00 audio/songrec Shazam client written in Rust
SongRec is an open-source Shazam client for Linux, written in Rust.

Features:
* Recognize audio from an arbitrary audio file.
* Recognize audio from the microphone.
* Usage from both GUI and command line (for the file recognition part).
* Provide an history of the recognized songs on the GUI, exportable to CSV.
* Continuous song detection from the microphone, with the ability to choose
your input device.
* Ability to recognize songs from your speakers rather than your microphone
(on compatible PulseAudio setups).
* Generate a lure from a song that, when played, will fool Shazam into
thinking that it is the concerned song.
2023-01-02T00:06:01-08:00 audio/netease-music-tui Netease cloud music terminal client by rust
Netease cloud music terminal client by Rust.
It has customizable theme colors.
2023-01-01T23:39:11-08:00 archivers/ouch Painless compression and decompression for your terminal
ouch stands for Obvious Unified Compression Helper.
It's a CLI tool for compressing and decompressing for various formats.
2023-01-01T23:31:36-08:00 audio/mmtc Minimal mpd terminal client that is simple yet highly configurable
Minimal mpd terminal client that aims to be simple yet highly configurable.
2023-01-02T09:06:14+01:00 security/teleport5 Centralized access gateway using the SSH protocol
What is Teleport?
=================
Teleport is a gateway for managing access to clusters of *nix servers via
SSH or the Kubernetes API. While it does also support connecting to
servers running traditional OpenSSH, its own node deamon is intended to be
used instead for additional functionality.

With Teleport it is simple to adopt SSH best practices like using
certificate-based access and enabling 2FA via TOTP (e.g. Google
Authenticator), U2F or an SSO provider. Cluster nodes can be accessed via
a CLI (tsh) or a Web UI which both allow for session sharing.

Teleport provides centralized user management as well as full session
recordings that can be played back for knowledge sharing or auditing
purposes. It can also be used to protect Web applications like dashboards.
2023-01-01T14:20:56-08:00 devel/typeshare Tool to synchronize type definitions between Rust and other languages
typeshare is
* tool to rule the types
* tool to FFI them
* tool to parse your Rust
2023-01-01T14:16:06-08:00 devel/selene Command line tool to help write correct and idiomatic Lua code
selene is a blazing-fast modern Lua linter written in Rust.

Priorities:
* It's okay to not diagnose every problem, as long as the diagnostics that are
made are never wrong
* Easy to extend and modify
* Easy to configure ... but the user should need to configure as little as
possible
2023-01-01T13:34:57-08:00 devel/spr Submit pull requests for amendable, rebaseable commits to GitHub
spr is a command-line tool for submitting and updating GitHub pull requests from
local Git commits that may be amended and rebased. Pull Requests can be stacked
to allow for a series of code reviews of interdependent code.
2023-01-01T13:19:47-08:00 shells/shellharden Corrective bash syntax highlighter
Shellharden is a syntax highlighter and a tool to semi-automate the rewriting
of scripts to ShellCheck conformance, mainly focused on quoting.

The default mode of operation is like cat, but with syntax highlighting in
foreground colors and suggestive changes in background colors.
2023-01-01T12:57:23-08:00 devel/the-way Code snippets manager for your terminal
The Way is a code snippets manager for your terminal.

Record and retrieve snippets you use every day, or once in a blue moon, without
having to spin up a browser. Just call the-way new to add a snippet with a
description, a language, and some tags attached.

'the-way search' fuzzy searches your snippets library (with optional filters on
language and tags) and lets you:
* edit a snippet with Shift-Right
* delete a snippet with Shift-Left
* copy a particular snippet to your clipboard (with Enter), so you can paste it
into whatever editor or IDE you're working with.
2023-01-01T11:33:49-08:00 textproc/sad CLI search and replace (Space Age seD)
sad is a batch file edit tool.
It will show you a really nice diff of proposed changes before you commit them.
Unlike sed, you can double check before you fat finger your edit.
2023-01-01T04:34:25-08:00 devel/snazy Snazzy json log viewer
Snazy is a simple tool to parse json or other type of logs and output them in a
nice format with nice colors.
2023-01-01T04:22:58-08:00 devel/treefmt One CLI to format the code tree
treefmt - one CLI to format the code tree.

When working on large code trees, it's common to have multiple code formatters
run against it. And have one script that loops over all of them. treefmt makes
that nicer.

Features:
* A unified CLI and output
* Run all the formatters in parallel.
* Cache which files have changed for super fast re-formatting.

Just type treefmt in any folder and it reformats the whole code tree.
2023-01-01T04:08:58-08:00 devel/tokio-console Debugger for async rust
tokio-console is an implementation of TurboWish/tokio-console, a diagnostics
and debugging tool for asynchronous Rust programs. the diagnostic toolkit
consists of multiple components:
* a wire protocol for streaming diagnostic data from instrumented applications
to diagnostic tools
* instrumentation for collecting diagnostic data from a process and exposing it
over the wire format
* tools for displaying and exploring diagnostic data, implemented as gRPC
clients using the console wire protocol
2023-01-01T03:33:09-08:00 devel/twiggy Code size profiler for Wasm
Twiggy is a code size profiler for Wasm. It analyzes a binary's call graph to
answer questions like:
* Why was this function included in the binary in the first place? Who calls it?
* What is the retained size of this function? I.e. how much space would be saved
if I removed it and all the functions that become dead code after its removal.
2023-01-01T02:35:33-08:00 sysutils/faketty Wrapper to exec a command in a pty, even if redirecting the output
A wrapper binary to exec a command in a pty, even if redirecting the output.

This allows logging the stdout and stderr (separately) of a process, without
the output being different from what you'd see in the terminal if you weren't
logging anything.
2023-01-01T02:27:39-08:00 misc/dijo Scriptable, curses-based, digital habit tracker
dijo is a habit tracker. It is curses-based, it runs in your terminal. dijo is
scriptable, hook it up with external programs to track events without moving a
finger. dijo is modal, much like a certain text editor.
2023-01-01T02:24:39-08:00 www/drill HTTP load testing application written in Rust
Drill is a HTTP load testing application written in Rust. The main goal for
this project is to build a really lightweight tool as alternative to other
that require JVM and other stuff.

You can write benchmark files, in YAML format, describing all the stuff you
want to test.

It was inspired by Ansible syntax because it is really easy to use and extend.
2023-01-01T02:16:10-08:00 security/authoscope Scriptable network authentication cracker
authoscope is a scriptable network authentication cracker. While the space for
common service bruteforce is already very well saturated, you may still end up
writing your own python scripts when testing credentials for web applications.
2023-01-01T02:08:19-08:00 devel/ghostie Github notifications in your terminal
ghostie displays Github notifications in your terminal.

Features:
* Runs as background process, fetching new github notifications in a 48h rolling
window.
* Polls every 1 minute and uses SQLite to persist local cache of notifications.
* Issues desktop notification when new notifications are received.
* View notifications in your terminal and opens them in your default browser
when selected.