Saravanan666/pypi-org huggingface dataset:
Package: pglogmon
Simple log monitor for PostgreSQL CSV logs.To enable CSV logs, please refer to the PostgreSQL docs.This monitor takes into account that some queries might contain newlines, and
properly parses the records.Installation:pip install --user git+https://github.com/exhuma/postgresql-logmon.gitAfter running as user installation like above, run it like this:~/.local/bin/pglogmon --helpOr start monitoring right away:~/.local/bin/pglogmon /psth/to/postgresql.csv
Package: pglogs
======pglogs======Save logs records in postgres.Log record can contain any num of fields.Logs format in the table:id  SERIALdata TEXT{"field1": "value", "field2": "value", "field3": "value"}# example of usefrom pglogs.models import Pg, LogRecordpg = Pg('pglogs', 'pglogs_user', '127.0.0.1', 'qwerty')pg.connect()log = LogRecord(pg)log.set_field('chef_request', """'{}[[[]dfdfd''']]--pdfdfdfdfd\\SOME HACKER BEEN HERE}'""")log.set_field('proxy_response', """dfdg'gfgfd'g'dsgd\'gfsdfg\'gdf/dgfd/fdg/f/dgd'\"\\''''""")log.commit()# example of use for log Flask requestsfrom pglogs.models import Pg, LogRecordfrom pglogs.utils import pack_request_logfrom flask import Flask, request, gapp = Flask(__name__)pg = Pg('pglogs', 'pglogs_user', '127.0.0.1', 'qwerty')@app.before_requestdef init_request_log():if not hasattr(g, 'log'):g.log = LogRecord(pg)@app.route("/")def hello():g.log.set_field('hello_request',pack_request_log(request))g.log.commit()return "Hello World!"if __name__ == "__main__":app.run()
Package: pgls
pglsCLI utility to display postgres database information as a tree.InstallationpipinstallpglsUsageBasic examplepglspostgres://user:password@db.example.com# shows all databases and all nested entitiesSort by sizepgls--sort=sizepostgres://user:password@db.example.com# shows heavier databases and tables firstHide some information (also this speeds up gathering)pgls--hide-columnspostgres://user:password@db.example.com# shows databases and tables without it's columnspgls--hide-tables--hide-views--hide-indexespostgres://user:password@db.example.com# shows only databases
Package: pglt
pG-lt (or phyloGenerator-light) is a pipeline for the automated generation of
phylogenies throughMass Phylogeny Estimation. It is adapted from
phyloGenerator (C) 2013 and was written by D.J. Bennett with additional help
and suggestions from W.D. Pearse, L. Hudson and A. Purvis.It makes use of external programs for phylogeny generation and bioinformatics,
these are: RAxML (Copyright (C) Stamatakis 2013), MAFFT (Copyright (C) 2013
Kazutaka Katoh) NCBI’s standalone BLAST suite 2.2.29+ and online API services
(Copyright NCBI (C) 2009). It also uses the following python packages:
Biopython (Copyright Cook (C) 2009), Dendropy (Copyright Sukumaran and Holder
(C) 2010) and Taxon Names Resovler (Copyright (C) Bennett 2014).For details on how to use pG-lt, please refer to its wiki:https://github.com/DomBennett/pG-lt/wikiFor any questions or comments, feel free to email:dominic.john.bennett@gmail.com.Copyright (C) 2015 Dominic John BennettThis program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details.You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
Street, Fifth Floor, Boston, MA 02110-1301 USA.
Package: pgm
# pgm - Process Group Manager
pgm is a tool used for managing groups of processes.
Groups of processes can be started and stopped together.
Individual processes are started in the background, but can be connected to later.
When processes stop running, their output remains available for debugging until the
processes is ‘removed’.## Dependencies
PGM currently uses tmux sessions to manage processes.## Example:Initialize a process group named ‘mine’$ pgm init mineInitialize a group named ‘mine’ with config file$ pgm init mine –config launch.iniList all groups$ pgm groups
1 Group:
mineList all processes in group ‘mine’$ pgm list mine
3 Processes
PGM Name        PID     Status      Command
top                 1001    Running             htop
netstat         1002    Running     watch -n 1 ‘netstat -naltp’
disksize        1003    Exited(1)       df -h
tcpdump         1004    Running         sudo tcpdump -i eth0Add the process ‘syslog’ to the session ‘mine’$ pgm add mine syslog –cmd tail -f /var/log/syslog
Adding process ‘syslog’ to ‘mine’ using: tail -f /var/log/syslogAdd a sudo process to the session ‘mine’$ pgm add mine iftop –sudo –cmd iftop -i eth0
Adding process ‘iftop’ to ‘mine’ using: sudo iftop -i eth0
[sudo] password for csrobot:Add a process ‘syslog’ to the session ‘mine’ using command from conf file$ pgm add mine syslog –config myconfig.iniAdding process ‘syslog’ to ‘mine’ using: tail -f /var/log/syslogConnect to process stdio$ pgm connect mine top
(opens tmux session to that process)Show latest output of a process$ pgm tail mine disksize
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1       209G  136G   63G  69% /Kill a process (Ctrl-c) Note: does not remove the process output from pgm$ pgm kill mine –name top
Sending Ctrl-c (SIGINT) to process ‘top’ in session ‘mine’Kill a process (Ctrl-c) and remove it$ pgm kill mine -r –name top
Sending Ctrl-c (SIGINT) to process ‘top’ in session ‘mine’
Removing ‘top’ from session ‘mineKill all processes (Ctrl-c)$ pgm kill mine –allKill a process (Ctrl-d)$ pgm kill mine -d –name top
Sending Ctrl-d (EOF) to process ‘top’ in session ‘mine’Kill a process (Ctrl-)$ pgm kill mine -q –name top
Sending Ctrl-(SIGQUIT) to process ‘top’ in session ‘mine’Kill a process$ pgm kill mine -9 –name top
Sending SIGINT to process ‘top’ in session ‘mine’Remove an exited process (only works on exited processes)$ pgm rm mine –name top
Removing ‘top’ from session ‘mine’
Package: pgmagick
Aboutpgmagick is a yet another boost.python based wrapper forGraphicsMagick.Installationinstall to:$ pip install pgmagickRequirementsPython3.5++ (or Python2.7), GraphicsMagick and Boost.Python.package install on Debian Buster:$ apt-get install g++ libgraphicsmagick++1-dev libboost-python-devpackage install on Ubuntu(test on Ubuntu10.04+):### Ubuntu11.10+ ###
$ apt-get install python-pgmagick

### Ubuntu10.04+ ###
$ apt-get install libgraphicsmagick++1-dev
$ apt-get install libboost-python1.40-devpackage install on Fedora:$ yum install GraphicsMagick-c++-devel
$ yum install boost-develGraphicsMagick from source package:$ ./configure --enable-shared=yes
$ make && make installMacOSXvia homebrew-cask(homebrew-pgmagick) with Python3usehomebrew-pgmagick$ brew tap hhatto/pgmagick
$ brew install pgmagickvia homebrew-cask(homebrew-pgmagick) with Python3via homebrew and pip with Python3on MacOSX (10.13.5~10.15.x):$ brew install python
$ brew install graphicsmagick
$ brew install boost-python3
$ pip install pgmagickWindowsNow, not official support.
However,unofficialbinary packages exists.http://www.lfd.uci.edu/~gohlke/pythonlibs/#pgmagickImageMagick supportpgmagick is supported to ImageMagick library. (version:0.4+)package install on Ubuntu(test on Ubuntu10.04+):$ apt-get install libmagick++-devshow library name and version:>>> from pgmagick import gminfo
>>> gminfo.library
'GraphicsMagick'    # or 'ImageMagick'
>>> gminfo.version
'1.3.x'
>>>Usagescale example:>>> from pgmagick import Image
>>> im = Image('input.jpg')
>>> im.quality(100)
>>> im.scale('100x100')
>>> im.sharpen(1.0)
>>> im.write('output.jpg')resize example:>>> from pgmagick import Image
>>> im = Image('input.jpg')
>>> im.filterType(FilterTypes.SincFilter)
>>> im.resize('100x100')
>>> im.write('output.jpg')composite example:>>> from pgmagick import Image, CompositeOperator as co
>>> base = Image('base.png')
>>> layer = Image('layer_one.png')
>>> base.composite(layer, 100, 100, co.OverCompositeOp)
>>> im.write('output.png')draw example:>>> from pgmagick import Image, DrawableCircle, DrawableText, Geometry, Color
>>> im = Image(Geometry(300, 300), Color("yellow"))
>>> circle = DrawableCircle(100, 100, 20, 20)
>>> im.draw(circle)
>>> im.fontPointsize(65)
>>> text = DrawableText(30, 250, "Hello pgmagick")
>>> im.draw(text)
>>> im.write('hoge.png')blob access:>>> from pgmagick import Image, Blob, Geometry
>>> blob = Blob(open('filename.jpg').read())
>>> blob.update(open('filename2.jpg').read())
>>> img = Image(blob, Geometry(600, 480))
>>> img.scale('300x200')
>>> img.write('out.jpg')create animated-GIF:from pgmagick import Image, ImageList, Geometry, Color

imgs = ImageList()
for color in ('red', 'blue', 'green', 'black', 'yellow'):
    imgs.append(Image(Geometry(200, 200), Color(color)))
imgs.animationDelayImages(100)
imgs.scaleImages(Geometry(100, 100))
imgs.writeImages('output.gif')more API detail… read toMagick++ API for GraphicsMagickdocument.Python APIs(NOTICE!! this api is alpha version!!):>>> from pgmagick.api import Image
>>> img = Image((300, 300), "gradient:#ffffff-#000000")
>>> img.scale(0.8)
>>> img.write('out.png')LinksPyPIProject PageProject Page (Old)
Package: pgmax
PGMaxPGMax implements generalfactor graphsfor discrete probabilistic graphical models (PGMs), and
hardware-accelerated differentiableloopy belief propagation (LBP)inJAX.General factor graphs: PGMax supports easy specification of general
factor graphs with potentially complicated topology, factor definitions,
and discrete variables with a varying number of states.LBP in JAX: PGMax generates pure JAX functions implementing LBP for a
given factor graph. The generated pure JAX functions run on modern accelerators
(GPU/TPU), work with JAX transformations
(e.g.vmapfor processing batches of models/samples,gradfor differentiating through the LBP iterative process),
and can be easily used as part of a larger end-to-end differentiable system.See ourcompanion paperfor more details.PGMax is under active development. APIs may change without notice,
and expect rough edges!Installation|Getting startedInstallationInstall from PyPIpip install pgmaxInstall latest version from GitHubpip install git+https://github.com/deepmind/PGMax.gitDeveloperWhile you can install PGMax in your standard python environment,
westronglyrecommend using aPython virtual environmentto manage your dependencies. This should help to avoid version conflicts and
just generally make the installation process easier.git clone https://github.com/deepmind/PGMax.git
cd PGMax
python3 -m venv pgmax_env
source pgmax_env/bin/activate
pip install --upgrade pip setuptools
pip install -r requirements.txt
python3 setup.py developInstall on GPUBy default the above commands install JAX for CPU. If you have access to a GPU,
follow the official instructionshereto install JAX for GPU.Getting StartedHere are a few self-contained Colab notebooks to help you get started on using PGMax:Tutorial on basic PGMax usageLBP inference on Ising modelImplementing max-product LBPforRecursive Cortical NetworksEnd-to-end differentiable LBP for gradient-based PGM training2D binary deconvolutionAlternative inference with Smooth Dual LP-MAPCiting PGMaxPlease consider citing ourcompanion paper@article{zhou2022pgmax,
  author = {Zhou, Guangyao and Dedieu, Antoine and Kumar, Nishanth and L{\'a}zaro-Gredilla, Miguel and Kushagra, Shrinu and George, Dileep},
  title = {{PGMax: Factor Graphs for Discrete Probabilistic Graphical Models and Loopy Belief Propagation in JAX}},
  journal = {arXiv preprint arXiv:2202.04110},
  year={2022}
}and using theDeepMind JAX Ecosystem citationif you use PGMax in your work.NoteThis is not an officially supported Google product.
Package: pg-metadata
DescriptionPostgreSQL metadata (DDL) grabber and database schema diffDependenciesPython 3psycopg2Installationpipinstallpsycopg2-binarypg-metadataGrabbing1 ) Create config file with connection params and other settings:{"connect":{"host":"localhost","port":5432,"database":"db","username":"some_user","password":"some_password"},"path":"/some/path/to/grabber/result/folder","exclude_schemas":["information_schema","pg_catalog"],"threads":8}2 ) By default script opens config fileconfig_grab.jsonfrom the same directory aszzz_Grabber.pyfile.3 ) Alternatively you can specify path to config file as a first run parameter.4 ) Run grabber:# Run with default config (config_grab.json)python"zzz_Grabber.py"# Run with specified config file pathpython"zzz_Grabber.py""/some/path/to/config.json"Compare (diff) databases1 ) Create config file with connection params and other settings:{"source":{"host":"localhost","port":5432,"database":"db_from","username":"user","password":"password"},"target":{"host":"localhost","port":5432,"database":"db_to","username":"user","password":"password"},"path":"/some/path/to/compare/result/folder","exclude_schemas":["information_schema","pg_catalog"]}2 ) By default script opens config fileconfig_diff.jsonfrom the same directory aszzz_Grabber.pyfile.3 ) Alternatively you can specify path to config file as a first run parameter.4 ) Run diff:# Run with default config (config_grab.json)python"zzz_Diff.py"# Run with specified config file pathpython"zzz_Diff.py""/some/path/to/config.json"LinksGitHubPyPI
Package: pgmigrations
pgmigrationsSQL migrations for projects using PostgreSQLExample UsageInitialise the migrationspgmigrations initThis will create a directory calledmigrationsin the current working directoryCreate a migrationpgmigrations create <tag>This will create a skeleton migration in themigrationsdirectory. The migration will consist of a directory with
the name<timestamp>_migrations_<tag>, for example20200701_1030_migrations_first_migration, which
contains two files;apply.sqlandrollback.sql.As the names suggests,apply.sqlwill be executed when the migration is applied androllback.sqlwill be
executed if the migraiton is rollbacked.Apply migrationspgmigrations apply --dsn=<dsn> [--path <colon separated list of migration locations>]orexport PGMIGRATIONS_DSN=<dsn>
export PGMIGRATIONS_PATH=<colon separated list of migration locations>
pgmigrations applyThis will apply any unapplied migrations. Each migration is applied in an atomic transaction.Rollback a migrationpgmigrations rollback --dsn=<dsn> [--path <colon separated list of migration locations>]orexport PGMIGRATIONS_DSN=<dsn>
export PGMIGRATIONS_PATH=<colon separated list of migration locations>
pgmigrations rollback <name>This will rollback an already applied migration.
Package: pgml-extension
PgML Extension - Postgres Machine LearningThis package implements data processing, training and scoring of ML models inside Postgres from PL/Python functions. It is dependent on the internal to Postgresplpyconnection and data access methods, so can only be used via a Postgres connection through the APIs exposed as native Postgres functions.InstallationPostgres requires that this package is installed into the system Python packages space:To install from pypi:sudopip3installpgml-extensionTo install from a clone of the repository:sudopython3setup.pyinstallUsageSeesql/install.sqlfor list of functions exposed through SQL. This package is not meant to be used directly.
Package: pgmock
pgmock provides utilities for obtaining and mocking out expressions in Postgres queries. For a quick start and
a full tutorial on using pgmock, view the documentation link below.DocumentationView the pgmock docs here.Installationpgmock can be installed with:pip3 install pgmockContributing GuideFor information on setting up pgmock for development and contributing changes, viewCONTRIBUTING.rst.Primary Authors@wesleykendall (Wes Kendall)@chris-hartfield (Chris Hartfield)@dargueta (Diego Argueta)@VincentLa (Vincent La)Other contributors can be found in the AUTHORS file
Package: pgmpy
pgmpypgmpy is a python library for working with Probabilistic Graphical Models.Documentation  and list of algorithms supported is at our official sitehttp://pgmpy.org/Examples on using pgmpy:https://github.com/pgmpy/pgmpy/tree/dev/examplesBasic tutorial on Probabilistic Graphical models using pgmpy:https://github.com/pgmpy/pgmpy_notebookOur mailing list is athttps://groups.google.com/forum/#!forum/pgmpy.We have our community chat atgitter.Dependenciespgmpy has the following non-optional dependencies:python 3.6 or highernetworkXscipynumpypytorchSome of the functionality would also require:tqdmpandaspyparsingstatsmodelsjoblibInstallationpgmpy is available both on pypi and anaconda. For installing through anaconda use:$condainstall-cankurankanpgmpyFor installing through pip:$pipinstall-rrequirements.txt# only if you want to run unittests$pipinstallpgmpyTo install pgmpy from the source code:$ git clone https://github.com/pgmpy/pgmpy 
$ cd pgmpy/
$ pip install -r requirements.txt
$ python setup.py installIf you face any problems during installation let us know, via issues, mail or at our gitter channel.DevelopmentCodeOur latest codebase is available on thedevbranch of the repository.ContributingIssues can be reported at ourissues section.Before opening a pull request, please have a look at ourcontributing guideContributing guide contains some points that will make our life's easier in reviewing and merging your PR.If you face any problems in pull request, feel free to ask them on the mailing list or gitter.If you want to implement any new features, please have a discussion about it on the issue tracker or the mailing
list before starting to work on it.TestingAfter installation, you can launch the test form pgmpy
source directory (you will need to have thepytestpackage installed):$pytest-vto see the coverage of existing code use following command$ pytest --cov-report html --cov=pgmpyDocumentation and usageThe documentation is hosted at:http://pgmpy.org/We use sphinx to build the documentation. To build the documentation on your local system use:$ cd /path/to/pgmpy/docs
$ make htmlThe generated docs will be in _build/htmlExamplesWe have a few example jupyter notebooks here:https://github.com/pgmpy/pgmpy/tree/dev/examplesFor more detailed jupyter notebooks and basic tutorials on Graphical Models check:https://github.com/pgmpy/pgmpy_notebook/CitingPlease use the following bibtex for citingpgmpyin your research:@inproceedings{ankan2015pgmpy,
  title={pgmpy: Probabilistic graphical models using python},
  author={Ankan, Ankur and Panda, Abinash},
  booktitle={Proceedings of the 14th Python in Science Conference (SCIPY 2015)},
  year={2015},
  organization={Citeseer}
}Licensepgmpy is released under MIT License. You can read about our license athere
Package: pgmq
pgmqA message queue built on top of Postgres.PurposeSometimes you have a Postgres database and need a queue.
You could stand up more infrastructure (SQS, Redis, etc), or you could use your existing database.
There are plenty of use cases for a persistent queue that do not require infinite scalability, snapshots or any of the other advanced features full fledged queues/event buses/message brokers have.FeaturesBest effort at most once delivery (messages are only delivered to one worker at a time)Automatic redelivery of failed messagesLow latency delivery (near realtime, uses PostgreSQL'sNOTIFYfeature)Low latency completion tracking (usingNOTIFY)Bulk sending and receivingFully typed async Python client (usingasyncpg)Persistent scheduled messages (scheduled in the database, not the client application)Possible features:Exponential backoffsDead letter queuesCustom delivery ordering keyResponses / completion messagesMessage attributes and attribute filteringFIFO deliveryBackpressure / bound queuesUnplanned features:Sending back response data (currently it needs to be sent out of band)Supporting "subscriptions" (this is a simple queue, not a message broker)ExamplesfromcontextlibimportAsyncExitStackimportanyioimportasyncpg# type: ignorefrompgmqimportcreate_queue,connect_to_queue,migrate_to_latest_versionasyncdefmain()->None:asyncwithAsyncExitStack()asstack:pool:asyncpg.Pool=awaitstack.enter_async_context(asyncpg.create_pool(# type: ignore"postgres://postgres:postgres@localhost/postgres"))awaitmigrate_to_latest_version(pool)awaitcreate_queue("myq",pool)queue=awaitstack.enter_async_context(connect_to_queue("myq",pool))asyncwithanyio.create_task_group()astg:asyncdefworker()->None:asyncwithqueue.receive()asmsg_handle_rcv_stream:# receive a single messageasyncwith(awaitmsg_handle_rcv_stream.receive()).acquire():print("received")# do some workawaitanyio.sleep(1)print("done processing")print("acked")tg.start_soon(worker)tg.start_soon(worker)asyncwithqueue.send(b'{"foo":"bar"}')ascompletion_handle:print("sent")awaitcompletion_handle()print("completed")tg.cancel_scope.cancel()if__name__=="__main__":anyio.run(main)# prints:# "sent"# "received"# "done processing"# "acked"# "completed"DevelopmentClone the repoStart a disposable PostgreSQL instance (e.gdocker run -it -e POSTGRES_PASSWORD=postgres -p 5432:5432 postgres)Runmake testSee this release on GitHub:v0.6.1
Package: pg-mutex
PG MUTEXPython wrapper around Postgrespg_advisory_lockandpg_try_advisory_lockfunctions. It is possible, thanks to a common connection to the database, to block certain pieces of python code by different python processes, on different nodes.Installationpipinstallpg-mutexUsagefrommuteximportmutexwithmutex(connection,['param1','param2']):# here is code that is guaranteed to be executed by only one process, even on different nodespass
Package: pgmuvi
pgmuviPython gaussian processes for multiwavelength variability inferencepgmuvi is based on GPyTorch and intended for us in infering the properties of astronomical sources with multiwavelength variability. It uses spectral-mixture kernels to learn an approximation of the PSD of the variability, which have been shown to be very effective for pattern discovery (seehttps://arxiv.org/pdf/1302.4245.pdf).
Package: pgn2fixture
pgn2fixtureA module that translates PGN files into Django fixturesHow it worksInstallpip install pgn2fixtureUsageIf we have the following PGN game:[Event "USSR Championship"]
[Site "Moscow URS"]
[Date "1955.03.12"]
[EventDate "1955.??.??"]
[Round "18"]
[Result "1-0"]
[White "Boris Spassky"]
[Black "Viktor Korchnoi"]
[ECO "D87"]
[WhiteElo "?"]
[BlackElo "?"]
[PlyCount "81"]

1. d4 Nf6 2. c4 g6 3. Nc3 d5 4. cxd5 Nxd5 5. e4 Nxc3 6. bxc3 Bg7 7. Bc4 O-O 8. Ne2 c5 9. O-O Nc6 10. Be3 Bg4 11. f3 Na5 12. Bxf7+ Rxf7 13. fxg4 Rxf1+ 14. Kxf1 cxd4 15. cxd4 Qd7 16. h3 Qe6 17. Qd3 Qc4 18. Qd2 Qa6 19. Qc2 Nc4 20. Qb3 Kh8 21. Kg1 Nd2 22. Bxd2 Qxe2 23. Be3 Rf8 24. e5 b5 25. Rc1 a5 26. Bg5 h6 27. Bxe7 a4 28. Qd1 Qe3+ 29. Kh1 Rf2 30. Qg1 Qf4 31. a3 Kh7 32. Bc5 h5 33. gxh5 Bh6 34. hxg6+ Kg7 35. Re1 Qg3 36. Bb4 Be3 37. Qh2 Qg5 38. e6 Bf4 39. Qg1 Qh4 40. e7 Rf3 41. Qh2 1-0We can load it into pgn2fixture as follows:from pgn2fixture import pgn2fixture

pgn = raw_pgn
game = pgn2fixture.Game(pgn)From then on, thegameobject will provide access to the PGN seven roster tag as follows:game.white # => Boris Spassky
game.black # => Viktor KorchnoiAll standard PGN roster tags are accessible via properties. All non-standard tags included in the raw PGN will be accesible via thegame.tagsvariable, which contains all tags from the PGN as Python dictionary such as the following:{'event': 'USSR Championship', 
     'site': 'Moscow URS', 
     'date': '1955.03.12', 
     'eventdate': '1955.??.??', 
     'round': '18', 
     'result': '1-0', 
     'white': 
     'Boris Spassky', 
     'black': 'Viktor Korchnoi', 
     'eco': 'D87', 
     'whiteelo': '?', 
     'blackelo': '?', 
     'plycount': '81', 
     'moves': '1. '1. d4 Nf6 2. c4 g6 etc'}In order to convert thegameobject into a Django fixture dictionary, just call the methodto_fixture()as follows:game.to_fixture(model: str)where the argumentmodelis a string with the name of the Django model.
As for the PK for the database, you will need to implement a way to create them as you need them.Author👤Josias AlvaradoGitHub:@pointerishTwitter:@pointerishLinkedIn:LinkedInBlogContributingContributions, issues, and feature requests are welcome!Feel free to check theissues page.LicenseThis project isMITlicensed.