Saravanan666/pypi-org huggingface dataset:
Package: gnuhealth-client
The GTK client allows to connect to the GNU Health HMIS component server from the
desktop.InstallationYou can install the GNU Health HMIS client via pip:$ pip3 install --user --upgrade gnuhealth-clientTechnologyThe GNU Health HMIS client is a Python application that derives from
the Tryton GTK client, with specific features of GNU Health and healthcare sector.The default profileThe GNU Health client comes with a pre-defined profile, which points to
the GNU Health community demo server:Server : federation.gnuhealth.org
Port : 8000
User : admin
Passwd : gnusolidarioGNU Health PluginsYou can download GNU Health plugins for specific functionality.For example:The GNU HealthCryptoplugin to digitally sign documents using GNUPGThe GNU HealthCamerato use cameras and store them directly
on the system (person registration, histological samples, etc..)TheFederation Record Locator, that communicates withthalamusand interacts with the GNU Health Information System and Person Master Index.More information about the GNU Health plugins at :https://en.wikibooks.org/wiki/GNU_Health/PluginsThe GNU Health client configuration fileThe default configuration file resides in:$HOME/.config/gnuhealth/<version>/gnuhealth-client.confUsing a custom greeter / bannerYou can customize the login greeter banner to fit your institution.In the section [client] include the banner param with the absolute path
of the png file.Something like:[client]
banner = /home/yourlogin/myhospitalbanner.pngThe default resolution of the banner is 500 x 128 pixels. Adjust yours
to approximately this size.DevelopmentThe development of the GNU Health client will be done on GNU Savannah,
using the Mercurial repository.Tasks, bugs and mailing lists will be onhealth-dev@gnu.org, for development.General questions can be done onhealth@gnu.orgmailing list.Homepagehttps://www.gnuhealth.orgDocumentationThe GNU Health GTK documentation will be at the corresponding
chapter in the GNU Health Wikibookhttps://en.wikibooks.org/wiki/GNU_Health
Package: gnu-health-fhir
gnu_health_fhirThis package aims to provide a functional FHIR interface to GNU Health data models. With the provided classes, one should be able to work to and from the back-end data from GNU Health in a FHIR-compatible way. The module, ultimately, should provide a full interface - CRUD, type conversions, serializers, and so on.DesignThe ultimate goal is that for every appropriate FHIR Resource there will be an adapter which interfaces with the backend data models.There are plans to extend some of the resources to better approximate the GNU Health data schemes. The FHIR specification and GNU Health storage format rarely overlap, many times requiring significant data contortions. This is an ongoing process and there is a decided lack of motivation to do too much heavy-lifting, consequently these 'hacks' should be kept to a minimum.ResourcesCurrently, the package at least partially supports reads of these FHIR resources:PatientPractitionerImmunizationConditionObservationDiagnosticReportMedicationStatementFamilyMemberHistoryProcedureEncounterClinicalImpressionCoverageNot every resource's element is currently supported. Some of the elements have no equivalent in GNU Health, do not apply, have not reached maturity, or are undesirable in other ways. The FHIR resources are still under active development which makes them a moving target. The goal is to support all the reasonable, appropriate elements.UsageThe easiest example is to use Proteus with this package:from proteus import config, Model
from gnu_health_fhir import Patient

#Connect to the GNU Health demo server
config = config.set_xmlrpc('http://admin:gnusolidario@health.gnusolidario.org:8000/health36/')

#Get the patient model
model = Model.get('gnuhealth.patient')

#Find the first patient
first_patient = model.find()[0]

#Convert to a fhir data object
patient = Patient.to_fhir_object(first_patient)

#Now you can use the data just like in fhirclient
print(patient.as_json())Libraries usedfhirclient (core FHIR data models)pendulum (sane datetimes)
Package: gnukek
KEKKinetic Encryption KeyThis library providessymmetric,asymmetric(public key),hybrid(symmetric + asymmetric) encryption.It was build usingcryptographylibrary and has uncomplicated interface.Algorithms:AESinCBCmode (128-256 bit)RSA(2048-4096 bit)Read the documentation on ReadTheDocs!InstallationUse the package managerpipto installKEK.pipinstallgnukekUsageImport key classes:fromKEK.hybridimportPrivateKEK,PublicKEKTo generate key:private_key=PrivateKEK.generate()To generate public key object:public_key=private_key.public_keyTo encrypt data:encrypted=public_key.encrypt(b"byte data")You can also encrypt data using private key object:private_key.encrypt()To decrypt data:decrypted=private_key.decrypt(encrypted)# b"byte data"Also supports chunk encryption/decryption:withopen("file","rb")asinput_file,open("file.out","wb")asoutput_file:forchunkinprivate_key.encrypt_chunks(input_file,1024):output_file.write(chunk)To sign data:data=b"byte data"signature=private_key.sign(data)To verify signature:public_key.verify(signature,data)# TrueBoth private and public keys can be serialized inPEMencodedPKCS8format:serialized_key=private_key.serialize()loaded_private_key=PrivateKEK.load(serialized_key)Hybrid encryptionHow it works?Ecryption:Data is encrypted via fresh generatedsymmetric key.Symmetric key is encrypted via publicasymmetric key.Decryption:Symmetric key is decrypted via privateasymmetric key.Data is decrypted via loadedsymmetric key.Encrypted data consists of:ContentLengthKey version1 byteKey id8 bytesEncrypted symmetric keyEqual to key length (256-512 bytes)Data encrypted via symmetric keySlightly larger than the length of original data and multiple of block length (<= len(original) + len(block))LicenseGPLv3 license
Package: gnukek-cli
KEK-cliKinetic Encryption Key CLICross-platform command-line interface forKEK.InstallationUse the package managerpipto installKEK-cli.pipinstallgnukek-cliUsageShow help:kek--helpGenerate new key:kekgenerateEncrypt file:kekencrypt{FILE}Decrypt file:kekdecrypt{FILE}List existing keys:keklistSet default private key:kekdefault{KEY_ID}Export key to file:kekexport{KEY_ID}Import key from file:kekimport{FILE}For more information see:kek{sub-command}--helpLicenseGPLv3 license
Package: gnulnx-datadiff
DataDiff is a library to provide human-readable diffs of python data structures.
It can handle sequence types (lists, tuples, etc), sets, and dictionaries.Dictionaries and sequences will be diffed recursively, when applicable.It has special-case handling for multi-line strings, showing them as a typical unified diff.Drop-in replacements for some nose assertions are available.  If the assertion fails,
a nice data diff is shown, letting you easily pinpoint the root difference.datadiffworks on Python 2.5 through Python 3.DataDiff project homepage:http://sourceforge.net/projects/datadiff/ExampleHere’s an example:>>> from datadiff import diff
>>> a = dict(foo=1, bar=2, baz=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> b = dict(foo=1, bar=4, baz=[0, 1, 2, 3, 4, 5, 6, 7, 8])
>>> print diff(a, b)
--- a
+++ b
{
-'bar': 2,
+'bar': 4,
 'baz': [
 @@ -5,11 +5,8 @@
  6,
  7,
  8,
 -9,
 -10,
 -11,
 ],
 'foo': 1,
}
>>>
>>> from datadiff.tools import assert_equal
>>> assert_equal([1, 2, 3], [1, 2, 5])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "datadiff/tools.py", line 29, in assert_equal
    raise AssertionError(msg)
AssertionError:
--- a
+++ b
[
@@ -0,2 +0,2 @@
 1,
 2,
-3,
+5,
]LicenseCopyright 2012 Dave BrondsemaLicensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: gnumake-tokenpool
gnumake-tokenpooljobclient and jobserver for the GNU make tokenpool protocolmonorepo with implementations in multiple languagespythonjavascriptc++bashsimilar projectsrust:https://github.com/alexcrichton/jobserver-rsC:https://github.com/olsner/jobclientgnumake tokenpool protocol specGNU make jobserver implementationJob SlotsPOSIX JobserverWindows Jobserverreference implementationgnu.org/software/make/savannah.gnu.org/git/?group=makegithub.com/mirror/makemake/src/job.cmake/src/posixos.cmake/src/w32/w32os.crelatedninja with jobclient and jobservergolang feature request:https://github.com/golang/go/issues/36868
Package: gnu-mo-files
GNU MO FilesRead and write GNU MO files.Created usingThe Format of GNU MO Filesarticle.To the contrary of what's written there,the file revisionis totally ignored.
The reason is that the difference between the revisions is not clear.The hash tabledoes not get written and ignored while reading, for Python dictionary uses its own hashing anyway.RequiresPython >= 3.6and no additional packages.
The code can be easily ported to older Python version, but I have no intention to.
Package: gnumpy
[This document is a copy of the original.The latest version is
available on Tijmen Tieleman’s
homepage.]Gnumpy is free software, but if you use it in scientific work that
gets published, you should citethis tech reportin your
publication.Documentation:here.Do you want to have both the compute power of GPU’s and the
programming convenience of Python numpy? Gnumpy + Cudamat will bring
you that.Gnumpy is a simple Python module that interfaces in a way almost
identical to numpy, but does its computations on your computer’s
GPU. Seethis example, training an
RBM using Gnumpy.Gnumpy runs on top of, and therefore requires, the excellentcudamatlibrary, written byVlad Mnih.Gnumpy can run in simulation mode: everything happens on the CPU, but
the interface is the same. This can be helpful if you like to write
your programs on your GPU-less laptop before running them on a
GPU-equipped machine. It also allows you to easily test what
performance gain you get from using a GPU. The simulation mode
requiresnpmat, written
byIlya Sutskever.  [npmat is
included in this distribution.]Gnumpy is licensed with a BSD-style license (i.e. it’s completely free
to use for everyone, also as a component in commercial software), with
one added note: if you use it for scientific work that gets published,
you must include reference to the Gnumpy tech report in your
publication. For details of the license, see the top of gnumpy.py.Recent changes:2012-07-25: Bugfix. gnumpy.dot(x, x), when x is a 1-dimensional array, didn’t work but now works.2011-06-06: gnumpy.dot() now takes arrays of ndim>2.2011-04-19: Bugfix: several bugs involving zero size arrays were fixed.2011-04-15: Bugfix. “x=gnumpy.zeros(10); x[array([])] = garray([])” didn’t work as it should. Now it does.2011-03-24: Added gnumpy.outer().2011-03-15: The ability to check for infs and nans automatically has been added to Gnumpy.2010-07-19: Cudamat now enables fast indexing with arrays of indices. Download the newest Cudamat to have fast indexing with arrays in Gnumpy.2010-07-08: Renamed the project to Gnumpy. It used to be called Gpunnumpy.
Package: gnuper
======
gnupergnuperis an open source python package for the preprocessing of mobile phone metadata whilst keeping privacy in mind. It is being developed by the spin-off projectknuper <https://www.knuper.com>_ of the Freie Universität Berlin.
The package creates features on antenna level off of mobile phone metadata like simple incoming to outgoing ratios of calls or sms as well as entropy and isolation indicators of antennas. Additionally one can include antenna averages of the bandicoot individual indicators developed by the MIT. Further information on this toolkit can be foundhere <http://bandicoot.mit.edu/>_.PrerequisitesPython3Apache SparkStructural OverviewThe following tree diagram shows the entire process from raw mobile phone meta data to final features on antenna level. In order to keep the process fast and the intermediate tables as small as possible, several mid-aggregations are taking place. We call these intermediate steps levels.
Each level represents another aggregation or transformation step. The color coding signifies the privacy risk. Orange is on user level, blue on antenna (single tower GPS coordinate) level... figure:: docs/Raw_Data_Levels.png
:alt: Data Levels
:scale: 60 %Level 0This level simply unifies and preprocesses (kick out unnecessary information) the raw format. Also obvious machines are being filtered as well as the files restructured into chunks of users.Level 1For each user a home antenna is being estimated and then interactions aggregated on user level per day and hour. Also bandicoot variables might be calculated if the flag is set.Level 2Antenna level. Users are being allocated to their home antenna and then aggregated in three different categories. First, for each week between weekend or holidays and working days. Second, for every hour of the day irrespective of the date. And third, for all interactions between each pair of antennas.Level 3Features are being created for several categories:alltime(ratios & scaled) - over the whole time periodvariance(variances over weeks) - to catch regional variationdaily(outgoing vs. incoming, week parts) - differences between working days and weekends/holidayshourly(workday, peaks) - differences between the usual working day and several peaksinteractions(distance, isolation, entropy) - network and geolocation relatedactive users(per home antenna) - number of users allocated to an antenna as their home antenna
For the exact formulas, have a look at the specific queries.Level 4Unite the feature categories with the bandicoot features (aggregated on antenna level) to one final dataset, ready for analysis.Sample DataIn order to create a small synthetic CDR sample data set (<20MB) run the ipython
scriptcdr_mockup.ipynb <cdr_mockup.ipynb>_ e.g. with Jupyter.SparkThe package has been built using SPARK version 2.2.1.Instructions on how to install Spark in Ubuntu (tested with 18.04):install java environmentsudo apt-get install default-jreinstall scalasudo apt-get install scaladownload sparkwget http://archive.apache.org/dist/spark/spark-2.2.1/spark-2.2.1-bin-hadoop2.7.tgzunzipsudo tar -zxvf spark-2.2.1-bin-hadoop2.7.tgzand removerm spark-2.2.1-bin-hadoop2.7.tgz
Package: gnupg
This module allows easy access to GnuPG’s key management, encryption and signature functionality from Python programs, by interacting with GnuPG through file descriptors. Input arguments are strictly checked and sanitised, and therefore this module should be safe to use in networked applications requiring direct user input. It is intended for use on Windows, MacOS X, BSD, or Linux, with Python 2.6, Python 2.7, Python 3.3, Python 3.4, or PyPy.
Package: gnuplot-kernel
Latest ReleaseLicenseBuild StatusCoveragegnuplot_kernelhas been developed for use specifically withJupyter Notebook. It can also be loaded as anIPythonextension allowing forgnuplotcode in the samenotebookaspythoncode.InstallationOfficial versionpipinstallgnuplot_kernelpython-mgnuplot_kernelinstall--userThe last command installs a kernel spec file for the current python installation. This
is the file that allows you to choose a jupyter kernel in a notebook.Development versionpipinstallgit+https://github.com/has2k1/gnuplot_kernel.git@masterpython-mgnuplot_kernelinstall--userRequiresSystem installation ofGnuplotNotebook(IPython/Jupyter Notebook)MetakernelDocumentationExample Notebooksforgnuplot_kernel.Metakernel magics, these are available when usinggnuplot_kernel.
Package: gnu-screen
What is this ?This was build to handle and manage gnu-screen session. Actually work well.Table of ContentsRequiredInstallationFunctionsScreenExempleRequiredPython: 3.8GNU-Screen: 4.08.00InstallationFirst make sure you have gnu-screen installed:$ apt-get install screenTo run this project, use pip:$ pip install gnu-screenFunctionsgetAll()Return all available Screens.ScreenCreate a representation of gnu-screen session :Screen(id, mode="")If you want to save logs change mode to's'.Events:closeWhen screen is closed.stdoutstrWhen something new is append in logFile.Methods:Screen.exist()Check if screen's session is running.Screen.setup()Fetch self variable with running session.Screen.setRule(*rules)Rules to apply in screen session.Screen.write(*stdins)Write something in screen session.Screen.setStdout(state)Watch over logFile to callstdoutEvent.Screen.logFile()Return logFile.Screen.on(call)Set an event (disconnect(),close(),stdout(log)).Screen.run(stdin=None)Connect/create to screen session.Screen.close()Close screen session.Screen.kill(signal=15)Kill screen session.KeyValues:Screen.idstr | NoneScreen session's id.Screen.logFilePathstr | NonePath of logFile is there one.Screen.eventsdictScreen session events.Screen.pidint | NonePid of screen session if is running.Screen.datestr | NoneDate of screen session if is running.Screen.statestr | NoneState of screen session if is running.Exempleimportosimportgnu_screenassc# Generate 10 screens sessionforninrange(10):scr=sc.Screen(id=f"test n°{n}")print(scr)scr.run()# Find and close the 10 screens sessionforscrinsc.getAll():print(scr)scr.close()# Create a new screen sessiontest=sc.Screen(id="final test",mode="r")test.run()print(test)# Allow "stdout" eventtest.setStdout()# Remove screen sessiondefclose():test.close()ifnottest.pid:print("Closed final test's screen session")else:test.kill()print("Killed test's screen session")#self killos.kill(os.getpid(),15)# Get stdout from screen session@test.ondefstdout(log):print("stdout:",log)if"!close"inlog:close()# Pipe input to the screen sessionwhiletest.pid:try:test.write(input())exceptKeyboardInterrupt:# Capture Ctrl + C to close screen sessionclose()
Package: gnusocial
Installationpip install gnusocialorpython3 setup.py installYou can also installpython-gnusocialpackage fromAUR.DocumentationDocumentation is hosted athttps://pygnusocial.readthedocs.io/en/latest/Basic usage>>> from gnusocial import statuses
>>> r = statuses.update('https://gnusocial.server.com', data={'status':"I've just installed #pygnusocial!", 'source':'python3'}, auth=('username', 'password'))If you want to help with the development of pygnusocial, check out thecontribution guide.
Package: gnutools-python
GNUTOOLSModules•Code structure•Installing the application•Makefile commands•Environments•Running the applicationRessourcesGnutools is a Python package that provides a few perks:Up to 3x speedup processing the disk by using system commands instead of python libs.A simple interface with optimized command executed from the system.A list of functions to ease the file processing in python.You can reuse your favorite Python packages such as NumPy, SciPy and Cython to extend ZakuroCache integration.ModulesAt a granular level, Gnutools is a library that consists of the following components:ComponentDescriptiongnutoolsContains the implementation of Gnutoolsgnutools.audioAudio processsinggnutools.fsFile system processinggnutools.concurrentConcurrent processinggnutools.gridGrid searchgnutools.remoteDownload files from gdrivegnutools.testsUnit testsgnutools.utilsUtilitariesCode structurefromsetuptoolsimportsetupfromgnutoolsimport__version__setup(name="gnutools-python",version=__version__,packages=["gnutools","gnutools.audio","gnutools.concurrent","gnutools.fs","gnutools.grid","gnutools.remote","gnutools.tests","gnutools.utils",],long_description="".join(open("README.md","r").readlines()),long_description_content_type="text/markdown",include_package_data=True,url="https://github.com/JeanMaximilienCadic/gnutools-python",license="MIT",author="Jean Maximilien Cadic",python_requires=">=3.6",install_requires=[r.rsplit()[0]forrinopen("requirements.txt")],author_email="git@cadic.jp",description="GNU Tools for python",classifiers=["Programming Language :: Python :: 3.6","License :: OSI Approved :: MIT License",],)Installing the applicationTo clone and run this application, you'll need the following installed on your computer:GitDocker DesktopInstall Docker Desktop on MacInstall Docker Desktop on WindowsInstall Docker Desktop on LinuxPythonInstall the package:# Clone this repository and install the codegitclonehttps://github.com/JeanMaximilienCadic/gnutools-python# Go into the repositorycdgnutools-pythonMakefile commandsExhaustive list of make commands:install_wheels
sandbox_cpu
sandbox_gpu
build_sandbox
push_environment
push_container_sandbox
push_container_vanilla
pull_container_vanilla
pull_container_sandbox
build_vanilla
build_wheels
auto_branchEnvironmentsDockerNoteRunning this application by using Docker is recommended.To build and run the docker imagemake build
make sandboxPythonEnvWarningRunning this application by using PythonEnv is possible butnotrecommended.make install_wheelsRunning the applicationPathlib10.1sto scan856631filesfrompathlibimportPathresults=[fforfinPath("/mnt/hdd/backup/ASR").glob("**/*.wav")]gnutools3.7sto scan856631filesfromgnutools.fsimportlistfilesresults=listfiles("/mnt/hdd/backup/ASR",[".wav"])RessourcesVanilla:https://en.wikipedia.org/wiki/Vanilla_softwareSandbox:https://en.wikipedia.org/wiki/Sandbox_(software_development)All you need is docker:https://www.theregister.com/2014/05/23/google_containerization_two_billion/Dev in containers :https://code.visualstudio.com/docs/remote/containersDelta lake partitions:https://k21academy.com/microsoft-azure/data-engineer/delta-lake/
Package: gnutty
GNUTTYPure Python HTTP ServerHow do I use this?So long as you have Python3.4 or higher, there are no
dependencies to worry about. Gnutty uses nothing but PythonTo start the example server, runpython3 ./srv/gnutty.pyFrom the root of the repository.You can confirm that it is running by openinghttp://127.0.0.1:8000/in a browser and checking you
receive the plaintext response ofOKYou can also runcurl-vhttp://127.0.0.1:8000To confirm the response from the Gnutty Server~  curl -v http://127.0.0.1:8000
*   Trying 127.0.0.1...
* TCP_NODELAY set
* Connected to 127.0.0.1 (127.0.0.1) port 8000 (#0)
> GET / HTTP/1.1
> Host: 127.0.0.1:8000
> User-Agent: curl/7.64.1
> Accept: */*
>
* HTTP 1.0, assume close after body
< HTTP/1.0 200 OK
< Server: Gnutty HTTP server 0.1
< Content-Type: text
< Content-Length: 2
<
* Closing connection 0
OK