Saravanan666/pypi-org huggingface dataset:
Package: dgit
dgit is an application on top of git.A lot of data-scientists’ time goes towards generating, shaping, and
using datasets. dgit enables organizing and using datasets with
minimal effort.dgit uses git for version management but structures the repository
content, and interface to suit data management tasks.ReaddocumentationNote: Only Python 3 supported for nowHistory0.1.7 (2016-04-23)APIBug fixesAdded auto mode…0.1.0 (2016-02-26)Boostrapping
Package: dgjiberg
testpackageSetupChoose a package name and replace the template nametestpackagein all files:./quick-start.shMyPackageName
rmquick-start.sh# you can delete this file afterwardsUpload to pypipipinstall--upgradepip
pipinstallwheeltwinePlace yourpypi tokenin$HOME/.pypirc:[pypi]
  username = __token__
  password = # either a user-scoped token or a project-scoped token you want to set as the defaultTo upload to pypi,makeInstallpipinstalltestpackage
pipinstall-e<path-to-repo>/testpackage
pipinstallgit+ssh://git@github.com/<path-to-repo>.git
Package: dgllge
Graph EmbeddingIntroductionThis module provides the services and implementation for various graph embedding models.Getting StartedInstallationYou can install the DGLL Graph Embedding version 1.0.3 fromPyPIas:pip install dgllgeUsage and Tutorialinput graph# import module
import ge


# Set Path to Data
data_dir = "Your Path to Data"
dataset = "File/Dataset Name"


# Load a Graph
inputGraph = ge.loadGraph(data_dir, dataset)Configurable Parameter for Graph EmbeddingembedDim = 2 # embedding size
numbOfWalksPerVertex = 2 # walks per vertex
walkLength = 4 # walk lenght
lr =0.025 # learning rate
windowSize = 3 # window sizeChoose One of the Following Graph Embedding Models# DeepWalk
rw = ge.DeepWalk(inputGraph, walkLength=walkLength, embedDim=embedDim, numbOfWalksPerVertex=numbOfWalksPerVertex, \
              windowSize=windowSize, lr = lr)# Node2Vec
rw = ge.Node2vec(inputGraph, walkLength=walkLength, embedDim=embedDim, numbOfWalksPerVertex=numbOfWalksPerVertex, \
               windowSize=windowSize, lr=lr, p = 0.5, q = 0.8)# Struc2Vec
rw = ge.Struc2Vec(inputGraph, walkLength=walkLength, embedDim=embedDim, numbOfWalksPerVertex=numbOfWalksPerVertex, \
              windowSize=windowSize, lr = lr)Skip Gram modelmodelSkipGram = ge.SkipGramModel(rw.totalNodes, rw.embedDim)Want Node Embedding or Edge Embedding# Learning Node Embedding
model = rw.learnNodeEmbedding(modelSkipGram)# Learning Edge Embedding
model = rw.learnEdgeEmbedding(modelSkipGram)Plot Embeddingge.plot_2DEmbedding(rw)Save Embedding to Diskge.saveEmbedding(data_dir, dataset, rw)Generate  Embedding for a Specific Node or Edgenode1 = 35
node2 = 40

# Get Embedding for a node
emb = rw.getNodeEmbedding(node1)
print("Node Embedding", emb)

# Get Embedding for an edge
emb = rw.getEdgeEmbedding(node1, node2)
print("Edge Embedding", emb)Utilize embedding for training classification models/classifiers# import modules
import ge
import numpy as np
import scipy.sparse as spLoad EmbeddingidsEmbeddingClsLabels = np.genfromtxt("cora.embedding", dtype=np.dtype(str))Prepare data for traininglabels = idsEmbeddingClsLabels[:, -1]
embedding = sp.csr_matrix(idsEmbeddingClsLabels[:, 1:-1], dtype=np.float32)tr = ge.TrainingClassifiers()
y = tr.labelEnocder(labels)Prepare Train test dataX_train, X_test, y_train, y_test = tr.prepareTrainTestData(embedding, labels, 0.33)Choose one of the following classifier for training a classifiery_pred = tr.applyDecisionTree(X_train.toarray(), y_train, X_test.toarray())y_pred = tr.applyLogistic(X_train.toarray(), y_train, X_test.toarray())y_pred = tr.applyRandomForest(X_train.toarray(), y_train, X_test.toarray())y_pred = tr.apply_GradientBoosting(X_train.toarray(), y_train, X_test.toarray())y_pred = tr.applyMLP(X_train.toarray(), y_train, X_test.toarray())Get Accuracyprint("Accuracy:", tr.accuracy(y_test, y_pred))LicenseDistributed under the MIT License. SeeLICENSEfor more information.(back to top)AcknowledgmentsData and Knowlege Engineering Lab (DKE)(back to top)LinksProject's GitHub Link:@Graph-EmbeddingProject's PyPI Link:@dgllge(back to top)
Package: dgmrf
dgmrfDeep Gaussian Markov Random Fields and their extensions.We use JAX for very fast computations. Check out the various notebooks to see what the library offers.Non-official reimplementations of the following models (work in progress, not everything is included in the library yet):@inproceedings{siden2020deep,
  title={Deep gaussian markov random fields},
  author={Sid{\'e}n, Per and Lindsten, Fredrik},
  booktitle={International conference on machine learning},
  pages={8916--8926},
  year={2020},
  organization={PMLR}
}

@inproceedings{graph_dgmrf,
    author = {Oskarsson, Joel and Sid{\'e}n, Per and Lindsten, Fredrik},
    title = {Scalable Deep {G}aussian {M}arkov Random Fields for General Graphs},
    booktitle = {Proceedings of the 39th International Conference on Machine Learning},
    year = {2022}
}

@article{lippert2023deep,
  title={Deep Gaussian Markov Random Fields for Graph-Structured Dynamical Systems},
  author={Lippert, Fiona and Kranstauber, Bart and van Loon, E Emiel and Forr{\'e}, Patrick},
  journal={arXiv preprint arXiv:2306.08445},
  year={2023}
}InstallationInstall the latest version with pippipinstalldgmrfDocumentationThe project's documentation is available athttps://hgangloff.gitlab.io/dmgrf/index.htmlContributingFirst fork the library on Gitlab.Then clone and install the library in development mode withpipinstall-e.Install pre-commit and run it.pipinstallpre-commit
pre-commitinstallOpen a merge request once you are done with your changes.ContributorsActive: Hugo Gangloff
Package: dgNN
dgNNdgNN is a high-performance backend for GNN layers with DFG (Data Flow Graph) level optimization. dgNN project is based onPyTorch.How to installthrough pippip install dgNNIf pip couldn't build dgNN, we recommend you to build dgNN from source.gitclonegit@github.com:dgSPARSE/dgNN.gitcddgNN
bashinstall.shRequirementCUDA toolkit >= 10.0
pytorch >= 1.7.0
scipy
dgl >= 0.7 (We use dgl's dataset)We prepare a docker to run our implementation. You could run our dgNN in a docker container.cddocker
dockerbuild-tdgNN:v1-fDockerfile.
dockerrun-itdgNN:v1/bin/bashExamplesOur training script is modified fromDGL. Now we implements three popular GNN models.Run GATDGL CodecddgNN/script/trainpythontrain_gatconv.py--num-hidden=64--num-heads=4--datasetcora--gpu0Run MonetDGL CodecddgNN/script/trainpythontrain_gmmconv.py--n-kernels3--pseudo-dim2--datasetcora--gpu0Run PointCloudWe use modelnet40-sampled-2048 data in our PointNet.DGL CodecddgNN/script/trainpythontrain_edgeconv.pyCollaborative ProjectsCogDLis a flexible and efficient graph-learning framework that uses GE-SpMM to accelerate GNN algorithms. This repo is implemented in CogDL as a submodule.LICENSEThis project is projected byApache-2.0License.
If you use our dgNN project in your research, please cite the following bib:@misc{zhang2021understanding,title={Understanding GNN Computational Graph: A Coordinated Computation, IO, and Memory Perspective},author={Hengrui Zhang and Zhongming Yu and Guohao Dai and Guyue Huang and Yufei Ding and Yuan Xie and Yu Wang},year={2021},eprint={2110.09524},archivePrefix={arXiv},primaryClass={cs.LG}}
Package: dgp-oauth2
Oauth2 Flask ServiceA generic OAuth2 authentication service and user permission manager.Based offOpenSpending auth service.Quick startClone the repo and installmake installRun testsmake testRun serverpython server.pyEnv VarsPRIVATE_KEY&PUBLIC_KEYan RSA key-pair in PEM format.
Seetools/generate_key_pair.shfor more info.GOOGLE_KEY&GOOGLE_SECRET: OAuth credentials for authenticating with GoogleGITHUB_KEY&GITHUB_SECRET: OAuth credentials for authenticating with GithubDATABASE_URL: A SQLAlchemy compatible database connection string (where user data is stored)EXTERNAL_ADDRESS: The hostname where this service is located onALLOWED_SERVICES:
Which permissions providers are available. A;delimited list of provider identifiers.
Each provider identifier takes the form of[alias:]provider, whereprovideris the name of a Python module
which exports aget_permissions(service, userid)function.INSTALLED_EXTENSIONS:
List of installed extensions. A;delimited list ofextension- the name of a Python modules which exports one or all of these functionson_new_user(user_info)on_user_login(user_info)on_user_logout(user_info)APICheck an authentication token's validity/auth/checkMethod:GETQuery Parameters:jwt- authentication tokennext- URL to redirect to when finished authenticationReturns:If authenticated:{"authenticated":true,"profile":{"id":"<user-id>","name":"<user-name>","email":"<user-email>","avatar_url":"<url-for-user's-profile-photo>","idhash":"<unique-id-of-the-user>","username":"<user-selected-id>"#Ifuserhasausername}}If not:{"authenticated":false,"providers":{"google":{"url":"<url-for-logging-in-with-the-Google-provider>"},"github":{"url":"<url-for-logging-in-with-the-Github-provider>"},}}When the authentication flow is finished, the caller will be redirected to thenextURL with an extra query parameterjwtwhich contains the authentication token. The caller should cache this token for further interactions with the API.Get permission for a service/auth/authorizeMethod:GETQuery Parameters:jwt- user token (received from/user/check)service- the relevant service (e.g.storage-service)Returns:{"token":"<token-for-the-relevant-service>""userid":"<unique-id-of-the-user>","permissions":{"permission-x":true,"permission-y":false},"service":"<relevant-service>"}Change the username/auth/updateMethod:POSTQuery Parameters:jwt- authentication token (received from/user/check)username- A new username for the user profile (this action is only allowed once)Returns:{"success":true,"error":"<error-message-if-applicable>"}Note: trying to update other user profile fields likeemailwill fail silently and return{"success":true}Receive authorization public key/auth/public-keyMethod:GETReturns:The service's public key in PEM format.Can be used by services to validate that the permission token is authentic.
Package: dgpost
dgpost: datagram post-processing toolkitSet of tools to post-process raw instrument data inyadg'sdatagramformat,NetCDFfiles, and tabulated data imported intopd.DataFrames.Capabilities:dgpostis indended to be used as part of your data processing pipeline, and works best with a series of timestamped data.Write aRecipeinyaml, and post-process your data fromNetCDFfiles,pd.DataFrames, oryadg.datagramsin a reproducible fashion, while keeping provenance information, and without touching the original data files.Post-process your data into pre-defined figures for your reports, or simply export your collatedpd.DataFrameinto one of the several supported formats!Usedgpostin your Jupyter notebooks by importing it as a python package:import dgpost.utilsto access the top-level functions for loading, extracting and exporting data; orimport dgpost.transformto access the library of validated transform functions.Features:dgpostcanloaddata from multiple file formats,extractdata from those files intopd.DataFramesand automatically interpolate the datapoints along the time-axis (generally the index of thepd.DataFrame) as necessary,pivotselected columns of the tables using another column as index,transformthe created tables using functions from the built-in library,plotdata from those tables using its matplotlib interface, andsavethe tables into several output formats.Of course,dgpostis fully unit-aware, and supports values with uncertainties by using thepint.Quantityanduncertainties.ufloatunder the hood.For a further overview of features, see theproject documentation.Contributors:Peter KrausUlrich Sauter
Package: dg-probability
Gaussian and Binomial DistributionsThis package contains code to perform basic mathematical operations on Gaussian and Binomial distributions. Operations include finding the mean and standard deviation (of both sample and population), plotting histograms for Gaussian distribution and plotting frequncy bar charts for Binomial distributions.Dummy input dataFor Gaussian distribution, you can test the package using the following dummy input data.1
3
99
100
120
32
330
23
76
44
31Here's some dummy data for a Binomial distribution. It contains the outcomes of 13 trials. A '0' denotes failure and a '1' denotes success.0
1
1
1
1
1
0
1
0
1
0
1
0Test the codeCopy the following code snippet in a.pyfile and execute it.fromdg_probabilityimportGaussiangaussian=Gaussian(10,5)print(f"Gaussian mean ={gaussian.mean}")print(f"Gaussian standard deviation ={gaussian.stdev}")This snippet is for the Binomial module.fromdg_probabilityimportBinomialbinomial=Binomial(0.25,60)print(f"Binomian mean ={binomial.mean}")print(f"Binomian standard deviation ={binomial.stdev}")Test the entire Binomial distribution moduleHere's how you can test the entire Binomial distribution module using the dummy data shown in the 'Input data' section. Create a file calleddata_binomial.txtand add the dummy data for Binomial distribution to it. Save this file in the same directory where your code is.# ignore if module is already importedfromdg_probabilityimportBinomialbinomial=Binomial()binomial.read_data_file('data_binomial.txt')binomial.calculate_mean()binomial.calculate_stdev()binomial.replace_stats_with_data()binomial.plot_bar()binomial.plot_bar_pdf()The methods for Gaussian distribution are similar.ContributionsThere is notCONTRIBUTIONS.mdfile yet but you are welcome to create PRs :)Source codehttps://github.com/dg1223/object-oriented-programming/tree/main/upload_to_pypi
Package: dgsamples
Introductiondgsamples is a package of sample image chips and vector files that can
be used for unit testing without having to maintain test data in each
code base that needs to be tested.Quick Startimportdgsamples# The code automatically discovers the data available and puts it on a# bunch object called samples which can be accessed directly:dgsamples.allsamples# This will pretty print the contents of the bunch# Finer grained access to the samples can be achieved by:dgsamples.wv2_longmont_1k.files# The above will produce a path similar to:# /path/to/dgsampledata/wv2_longmont_1k/...M2AS-053792616010_01_P001.TIL'# /path/to/dgsampledata/wv2_longmont_1k/...P2AS-053792616010_01_P001.TIL'# If the samples have a filename_map.PVL file provided, there will also be# sensor specific shotcuts available in an OrderedBunch object:dgsamples.wv2_longmont_1k.ms# The above will produce a path to the sensor .TIL file:# /path/to/dgsampledata/wv2_longmont_1k/...M2AS-053792616010_01_P001.TIL'# The .TIL file can be ingested with geoio as:importgeoioimg=geoio.DGImage(dgsamples.wv2_longmont_1k.ms)# However, these links are to real files on disk and can be read with# an appropriate application.fromosgeoimportgdalobj=gdal.Open(dgsamples.bayou_chip.extract_test)# orimportfionas=fiona.open(dgsamples.bayou_vectors.poly)# The sample data can also be retrieved through the "file" bunch key:dgsamples.bayou_vectors.files# The above will produce something similar to:# ['/path/to/dgsampledata/.../extract_test_point.shp',#  '/path/to/dgsampledata/.../extract_test_poly.shp']Adding Data SetsNew data can be added directly into the “dgsamples” package and will be
dynamically discovered on import.  The dynamic discovery code uses the
following logic when determining what type of data exists in a directory:if".TIL found":"return all .TILs and stop"elif".TIF found":"return all .TIFs and stop"elif".shp or .json found":"return all .shp and .json then stop"If a file named “filename_map.PVL” is added to a sample directory, the key/
value pairs in the file will be used to map files to an key entry on the
returned OrderedBunch object.If a file named “notes.txt” is present in the sample directory, the content
will be added to a “notes” entry on the OrderedBunch object.
Package: dgtl-pyqldb
DGTL Health AWS Quantum Ledger Database WrapperUse this code to access the ledger based databases.As of writing,2022-04-07, the pyqldb library has a dependency that doesn't
compile on Apple ARM-processors. For local development make a venv
with the intel64-python to use Rosetta2 emulation.
Compiling with --platform linux/arm64 using docker will work normally.Installation(Optional) Create venv:python3 -m venv venvor on Apple Silicon:python3-intel64 -m venv venv(Optional) Activate venv:source venv/bin/activateInstall:python -m pip install dgtl-pyqldbUsageMake sure your AWS credentials are set-up usingaws-configfrom dgtl_pyqldb.ledger_helper import LedgerHelperlh = LedgerHelper(ledger_name="pyqldb_tests", table="test_ledger", index="PID", region="eu-central-1")
Package: dgtools
dgtoolsdgtools is a complete toolkit for developing software for theDigiruleseries (2A/2U) of hardware bybradsprojects.OverviewdgasmThe assembler, accepts a human readable.asmtext file with Digirule ASM and
produces:A.dgbbinary file with compiled code ready for simulation bydgsim.py.A.hexfile (in the case of 2U) to be downloaded to the board.dginspectThe binary file "inspector", accepts a.dgbbinary file and produces a human readable
"dump" of the full 256 byte memory range to stdout. It also allows a user to apply certain
modifications to the memory space without re-compiling.dgsimThe Digirule Virtual Machine, accepts a.dgbbinary file and produces:A human readable HTML (themeable) trace of every state change the CPU goes through at each
timestep of execution.An additional.dgbfile that contains the final state of the memory space at the end of
program execution.These tools work together to write, debug and simulate code for the Digirule 2 prior to transfering it to the
actual hardware.dgtoolsalso includes some "extras", such as:A Sublime text.dsfASM plugin,A console gui (dgui.py) that can handle compilation/simulation in one stepA code formatter (dgform.py), to pretty print source code.BrainfuckandSuper Stack!compilers for the Digirule 2U.The most common workflow is to:Use a text editor to write human readable assembly code.Calldgasm.pyto compile the binaryCalldgsim.pyto run and debug the binary(Alternatively, calldguito perform both of the above in sequence)Usedginspect.pyto check a binary file, get/set values from the virtual machine or key the code in.InstallationPre-requisitesLinuxPython >=3.6virtualenvInstall from PyPi with pippip install dgtoolsInstall latest development versionCheckout the dgtools repository> virtualenv -p python3.8 pyenv> source pyenv/bin/activateTo start usingdgtools:pip install -e ./(From within thedgtools/directory that contains thesetup.pyfile)This will make thedgtoolsscripts callable from any position in the filesystem, as long as thepyenvvirtual environment is activated.If you are interested in developingdgtoolsfurther:pip install -r requirements.txtWhere to from here?dgtoolsdocumentation is up onReadTheDocsand of course
indoc/.Practical examples of how to usedgtoolsare available inthis introductory walkthrough.Once you familiarise yourself with the tools and Digirule's ASM, you might want to move tothe advanced walkthroughor
check out otherprogramming examplesindg_asm_eamples/.dgrdo.orgThe ASM toolchain along with the brainfuck and Super Stack! compilers is available online athttps://www.dgrdo.org.
For more information seethis introduction on its functionalityEnjoy!Athanasios Anastasiou
Package: dg-util
Package dg_utilv 0.0.15Package dg_util consists of different interface of commonly used basic functions in development process to help reduce redoundancy and keep your codes clean. More features will be updated in future.Install:pipinstalldg_utilUninstall:pipuninstalldg_utilFeaturesImage ReprocessingCrop face images with landmark.crop_imagecrop_image_from_pathFace ParsingGenreate face parsing with BiSeNet。parsing_faceparsing_facesRembgRemove background.bg.move
Package: dg-util-face-parsing
Face ParsingGenreate face parsing with BiSeNet。
pip install dg_face_parsingparsing_faceparsing_facesUsagedg_util.face_parsing.parsing_face(input_path, output_path)
*input_img- Image data()PIL.image.
*output_path- File path of output image(string, Blank as default).Opional, if output_path is blank, result image returned as cv2.image. Else, result image saved in output path and True returned.
*Return- Image data || Nonesdg_util.face_parsing.parsing_faces(input_folder, output_folder)
*Return- None
*input_folder- File path of input folder(string).
*output_folder- File path of output folder(string).
Package: dgut-inet-auth
dgut-inet-authLog in to Dongguan University of Technologies campus internet.Installation$pipinstall-Udgut-inet-authUsageCreate a config file with this structureyour user id
your passwordThen run$dgut-inet-auth<configfile>Return values:Exit code0, json output: successfully logged in.Exit code0, no output: already authenticated, skip.Exit code1: network is unreachable.You can optionally configure the firewall mark this program uses with aFWMARKenvironment variable to work with policy routing.Use with systemdCreate service unit:# /etc/systemd/system/dgut-inet-auth.service[Unit]After=network.targetDescription=DGUT campus internet authentication[Service]ExecStart=dgut-inet-auth /path/to/dgut-inet-auth.confType=oneshotCreate timer unit:# /etc/systemd/system/dgut-inet-auth.timer[Unit]Description=Auto authentication for DGUT campus internet[Timer]OnCalendar=minutely[Install]WantedBy=timers.targetEnable systemd timer#systemctldaemon-reload#systemctlenable--nowdgut-inet-auth.timerUse with Nix flakes{inputs.dgut-inet-auth.url ="github:chuangzhu/dgut-inet-auth";outputs ={self,nixpkgs,dgut-inet-auth}:{# Replace your-host-name to your machinenixosConfigurations.your-host-name =nixpkgs.lib.nixosSystem{system ="x86_64-linux";modules =[dgut-inet-auth.nixosModules.dgut-inet-auth{services.dgut-inet-auth.enable =true;# Specify your config file hereservices.dgut-inet-auth.configPath =./dgut-inet-auth-config-file;}];};};}services.dgut-inet-auth.enable: enable systemd timer for auto authentication.services.dgut-inet-auth.configPath: config file location.services.dgut-inet-auth.checkInterval:systemd.time(7)expression for timer interval.
Package: dgx
dgxGenerate Dealergeek APIInstallationUse pip to install the package:pipinstalldgxUsageThis package allows to generate an API structure, with some basic libraries.New projectCreate a new projectdgx-imy-appAdd moduleThis package has some default modules that you can add.brandpersonneldgx-abrandNew moduleIf you want create a module, can you write this command.dgx-cmy-moduleDelete projectYou must be in the root folder of the project, my-app-projectdgx-dmy-app