Saravanan666/pypi-org huggingface dataset:
Package: ldimbenchmark
LDIMBenchmarkLeakage Detection and Isolation Methods BenchmarkInstead of collecting all the different dataset to benchmark different methods on. We wanted to create a Benchmarking Tool which makes it easy to reproduce the results of the different methods locally on your own dataset.It provides a close to real-world conditions environment and forces researchers to provide a reproducible method implementation, which is supposed to run automated on any input dataset, thus hindering custom solutions which work well in one specific case.UsageInstallationpipinstallldimbenchmarkPythonfromldimbenchmark.datasetsimportDatasetLibrary,DATASETSfromldimbenchmarkimport(LDIMBenchmark,BenchmarkData,BenchmarkLeakageResult,)fromldimbenchmark.classesimportLDIMMethodBasefromtypingimportListclassYourCustomLDIMMethod(LDIMMethodBase):def__init__(self):super().__init__(name="YourCustomLDIMMethod",version="0.1.0")deftrain(self,data:BenchmarkData):passdefdetect(self,data:BenchmarkData)->List[BenchmarkLeakageResult]:return[{"leak_start":"2020-01-01","leak_end":"2020-01-02","leak_area":0.2,"pipe_id":"test",}]defdetect_datapoint(self,evaluation_data)->BenchmarkLeakageResult:return{}datasets=DatasetLibrary("datasets").download(DATASETS.BATTLEDIM)local_methods=[YourCustomLDIMMethod()]hyperparameters={}benchmark=LDIMBenchmark(hyperparameters,datasets,results_dir="./benchmark-results")benchmark.add_local_methods(local_methods)benchmark.run_benchmark()benchmark.evaluate()CLIldimbenchmark--helpRoadmapv1: Just Leakage Detectionv2: Provides Benchmark of Isolation Methodshttps://mathspp.com/blog/how-to-create-a-python-package-in-2022Developmenthttps://python-poetry.org/docs/basic-usage/# python 3.10# Use Environmentpoetryconfigvirtualenvs.in-projecttruepoetryshell
poetryinstall--withoutci# --with ci# Testpoetrybuild
cp-rdisttests/distcdtests
dockerbuild.-ttestmethod
pytest-s-olog_cli=truepytesttests/test_derivation.py-k'test_mything'pytest--testmon
pytest--snapshot-update# Pytest watchptw
ptw----testmon# Watch a file during developmentnpminstall-gnodemon
nodemon-Lexperiments/auto_hyperparameter.py# Test-Publishpoetryconfigrepositories.testpypihttps://test.pypi.org/legacy/
poetryconfighttp-basic.testpypi__token__pypi-your-api-token-here
poetrybuild
poetrypublish-rtestpypi# Real Publishpoetryconfigpypi-token.pypipypi-your-token-hereDocumentationhttps://squidfunk.github.io/mkdocs-material/https://click.palletsprojects.com/en/8.1.x/poetry shell
mkdocs serveTODOLDIMBenchmark:
Data Cleansing before working with themper sensor type, e.g. waterflow (cut of at 0)removing datapoints which are clearly a malfunction
Package: ldis
ldisldis.One to two paragraph statement about your product and what it does.InstallationOS X & Linux:Clone the repository:gitclonehttps://github.com/polyrand/setDNS.gitRun:chmod+xsetdns.py
./setdns.pyDevelopment setupDependency management is done with pip-tools + venv (stdlib).Framework requirements are in requirements/main.in (main.txt are the pinned ones). Development and documentation requirements are in requirements/dev.in (main.txt are the pinned ones)DocumentationDocumentation is written in markdown using mkdocs. In order to work on it, run:mkdocsserveNow it will be available atlocalhost:8000.Usage exampleA few motivating and useful examples of how your product can be used. Spice this up with code blocks and potentially more screenshots.For more examples and usage, please refer to the [Wiki][wiki].Release History0.2.1CHANGE: Update docs (module code remains unchanged)0.2.0CHANGE: RemovesetDefaultXYZ()ADD: Addinit()0.1.1FIX: Crash when callingbaz()(Thanks @GenerousContributorName!)0.1.0The first proper releaseCHANGE: Renamefoo()tobar()0.0.1Work in progressMetaRicardo Ander-Egg Aguilar –@ricardoanderegg–ricardoanderegg.comgithub.com/polyrandlinkedin.com/in/ricardoandereggDistributed under the XYZ license. SeeLICENSEfor more information.ContributingFork it (https://github.com/polyrand/yourproject/fork)Create your feature branch (git checkout -b feature/fooBar)Commit your changes (git commit -am 'Add some fooBar')Push to the branch (git push origin feature/fooBar)Create a new Pull RequestMIT LicenseCopyright (c) [year] [fullname]Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: ldit
lditList Docker hub Image Tags.Requirementspython>=3.2requestsInstallation$ pip3 install -U lditUsageCLIldit [-h] image [image ...]

positional arguments:
  image       image name, eg. fedora, google/debian etc.

optional arguments:
  -h, --help  show this help message and exitAs modulefromldit.lditimportlist_tagsprint(list_tags('image'))ExampleCLI$ ldit google/debian fedora
The image 'google/debian' on Docker Hub got following tag(s):
jessie
wheezy
The image 'fedora' on Docker Hub got following tag(s):
31
rawhide
30
29
latest
26
27
28
branched
25
26-modular
modular
24
heisenbug
20
21
22
23As module>>> from ldit.ldit import list_tags
>>> print(list_tags('google/debian'))
['jessie', 'wheezy']
>>> print(list_tags('fedora'))
['31', 'rawhide', '30', '29', 'latest', '26', '27', '28', 'branched', '25', '26-modular', 'modular', '24', 'heisenbug', '20', '21', '22', '23']
Package: ldlite
LDLiteCopyright (C) 2021-2022 The Open Library Foundation. This software is
distributed under the terms of the Apache License, Version 2.0. See
the fileLICENSEfor more information.LDLite is a lightweight, open source reporting tool for Okapi-based
services. It is part of the Library Data Platform project and
provides basic LDP functions without requiring the server to be
installed.To install LDLite or upgrade to the latest version:$python-mpipinstall--upgradeldlite(On some systems it might bepython3rather thanpython.)To extract and transform data:$python>>>importldlite>>>ld=ldlite.LDLite()>>>ld.connect_okapi(url='https://folio-juniper-okapi.dev.folio.org/',tenant='diku',user='diku_admin',password='admin')>>>db=ld.connect_db()>>>_=ld.query(table='g',path='/groups',query='cql.allRecords=1 sortby id')ldlite:querying:/groupsldlite:createdtables:g,g__t,g__tcatalog>>>ld.select(table='g__t')__id |                  id                  |         desc          | expiration_offset_in_days |   group   
------+--------------------------------------+-----------------------+---------------------------+-----------
    1 | 3684a786-6671-4268-8ed0-9db82ebca60b | Staff Member          |                       730 | staff     
    2 | 503a81cd-6c26-400f-b620-14c08943697c | Faculty Member        |                       365 | faculty   
    3 | ad0bc554-d5bc-463c-85d1-5562127ae91b | Graduate Student      |                           | graduate  
    4 | bdc2b6d4-5ceb-4a12-ab46-249b9a68473e | Undergraduate Student |                           | undergrad 
(4 rows)>>>_=ld.query(table='u',path='/users',query='cql.allRecords=1 sortby id')ldlite:querying:/usersldlite:createdtables:u,u__t,u__t__departments,u__t__personal__addresses,u__t__proxy_for,u__tcatalog>>>cur=db.cursor()>>>_=cur.execute("""CREATE TABLE user_groups ASSELECT u__t.id, u__t.username, g__t.groupFROM u__tJOIN g__t ON u__t.patron_group = g__t.id;""")>>>ld.export_excel(table='user_groups',filename='groups.xlsx')FeaturesQueries Okapi-based modules and transforms JSON data into tables for
easier reportingFull SQL query support and export to CSV or ExcelCompatible with DBeaver database toolCompatible with DuckDB and PostgreSQL database systemsPostgreSQL support enables:Sharing the data in a multiuser databaseAccess to the data using more database toolsStoring the data in an existing LDP database if availableRuns on Windows, macOS, and Linux.More examplesAn example running in Jupyter
NotebookLoading sample data from FOLIO demo
sitesUsing LDLite with SRS MARC dataLDLite resourcesLDLite API documentationThe LDP project runs a Slack workspace which is a good place to ask
questions or to share your work. It also serves as a community space
for working together on library data problems. To request an invitation,
use theContact pageon the LDP website.Report bugs atIssuesOther resourcesFOLIO API documentationPython learning resources
Package: ldm
Infoldm.py 2018-05-25Author: Zhao Mingming <471106585@qq.com>Copyright: This module has been placed in the public domain.version:0.1.0-add compare2dirversion:0.1.1-add face_rec_msversion:0.1.3-add compare2imglistClasses:
-LDM: you can use a function to get landmarks and face feature  with no other libsFunctions:face_feature: the feature of face in the image for face recognitionlandmarks: get the landmarks and face in the imageface_rec: return the face similarity of the  face in two imageshas_same_person: return a int(>0) if there have a same person in two images,otherwise 0compare2dir: compare the face in the images of the two dirs,and return the rate ,score_avg,class_id1,class_id2compare2imglist: compare the face in the imglist ,and return the rate ,score_avg,class_id1,class_id2How To Use This Moduleexample code:imagepath="closed_eye/9.jfif"img=io.imread(imagepath)img1=imgimagepath="closed_eye/14.jfif"img2=io.imread(imagepath)ldmer=ldm.LDM()printimg.shape[0]ldl,facel,txt=ldmer.landmarks(img)printtxtforldinldl:print10*'-'print'nose:'printld['nose']forfaceinfacel:print10*'-'print'face:'printface.top()printface.left()printface.width()printface.height()printface.bottom()printface.right()x,y,w,h=[face.top(),face.left(),face.width(),face.height()]printx,y,w,hprint"feature:"ffl=ldmer.face_feature(img,facel)forffinffl:printhelp(ff)print'ff='+str(ff)print'len(ff)='+str(len(ff))print'ff[0]='+str(ff[0])print'ff[127]='+str(ff[127])print"face compare:"printldmer.face_rec(img1,img2)printldmer.has_same_person(img1,img2)printldmer.has_same_person(img2,img2)print"face number:"printldmer.face_number(img,facel)Refreshadd a function : ldmer.imread(imgpath)
modify  the return value number to: has_flag,max_score=ldmer.has_same_person(img1,img2)
Package: ldm-python-client-lib
LDMLoggerClass LDMLogger contains methods for working with LDM framework.Methods:definit(self, user_token, project_id=None, server_url="http://localhost:5000", root_dir=Path(os.getcwd()).parent, should_upload_sources = False)Creates new instance of class LDMLoggerdef start_run(self, comment = "", git_commit_url = "" ):Starts a new rundef log(self, body):Logs message msg to server.def finish_run(self):Finish the current run.def validate(self, results, dataset_type="Train"):Validate on dataset.def upload_file(self, file_name, comment = ""):Uploads file (file_name) to the logging server and attaches it to the current run.def add_project(self, name, project_type, description=""):Adding project.def upload_dataset(self, path_to_dataset,dataset_type_in="Train"):Uploads dataset to server.def upload_sources(self):Creates a .zip of root_dir and uploads it to the LDM server.def download_dataset(self, path="", dataset_type_in="Train"):Downloads dataset from server.def save_colab_notebook_history_to_file(self, file_name):Creates new notebook containing history of all executed cells of the current notebook.Change log[0.0.1] - 2020-12-09[0.0.3] - 2021-02-10[0.0.4] - 2021-02-12AddedFunctions fordataset uploaddataset downloadproject creationresult validation on a specific datasetChangedchanged package structure (only one package (logger) is uploaded)removed all examples from package loggerclass LDMLogger has package visibilityRemoved[0.0.6] - 2021-02-17Changedstart_run does not upload sources by default[0.0.7] - 2021-03-19AddedFunction to save notebook[0.0.8] - 2021-03-20RemovedN/AChangedUpdated readme and docsAddedN/A
Package: ldmud-efun-alternatives
Python Efun alternatives package for LDMudThese are python efuns that mirror internal efuns of LDMud.They can be used as a starting point to modify their behavior or to add
to an already running LDMud instance that was compiled without these.This package contains the following efuns:jsonmodule:mixed json_parse(string jsonstring)string json_serialize(mixed data)UsageInstall from the python package indexThe efun package can be downloaded from the python package index:pip3 install --user ldmud-efun-alternativesBuild & install the package yourselfYou can build the package yourself.First clone the repositorygit clone https://github.com/ldmud/python-efun-alternatives.gitInstall the packagecd python-efun-alternatives
python3 setup.py install --userAutomatically load the modules at startupAlso install theLDMud Python efunsand use itsstartup.pyas the Python startup script for LDMud.
It will automatically detect the installed Python efuns and load them.Manually load the modules at startupAdd the following lines to your startup script:import ldmudefunalternatives.json

ldmudefunalternatives.json.register()Have fun!
Package: ldmud-efuns
Python Efun package for LDMudThese are routines and python efuns for management of Python efuns and types with LDMud 3.5 and later.The package allows efuns and types to be dynamically detected, registered and reloaded.This package contains the following efuns:void python_reload()string python_efun_help(string efunname)UsageInstall from the python package indexThe efun package can be downloaded from the python package index:pip3 install --user ldmud-efunsBuild & install the package yourselfYou can build the package yourself.First clone the repositorygit clone https://github.com/ldmud/python-efuns.gitInstall the packagecd python-efuns
python3 setup.py install --userAutomatically load the modules at startupUsestartup.pyas the Python startup script for LDMud.
It will automatically detect the installed python efuns and load them.You can deactivate single efuns with a configfile.ldmud-efunsin your home directory, with the following contents[efuns]
name_of_the_efun = off

[types]
name_of_the_type = offManually load the modules at startupAdd the following lines to your startup script:import ldmudefuns.reload
import ldmudefuns.help

ldmudefuns.reload.register()
ldmudefuns.help.register()Have fun!
Package: ldndc2nc
LandscapeDNDC inventory postprocessor to netCDF formatOverviewThis package converts LanscapeDNDC output to netCDF files for selected variables.
Currently used for Viet Nam inventory, but in general applicable for all raster-
based LandscapeDNDC simulations.Installation / UsageTo install use pip:$ pip install ldndc2ncContributingPlease file a pull request (PR) at githubhere.Exampleldndc2nc -r REFDATA.nc,cid -y 2000-2010 -o output.nc ldndc_results_dir ldndc_netcdf_dirUsageusage: ldndc2nc [-h] [-c MYCONF] [-l PATTERN] [-o OUTFILE] [-r FILE,VAR] [-s]
                [-S] [-v] [-y YEARS]
                indir outdir

positional arguments:
  indir        location of source ldndc txt files
  outdir       destination of created netCDF files

optional arguments:
  -h, --help   show this help message and exit
  -c MYCONF    use MYCONF file as config (default: None)
  -l PATTERN   limit files by PATTERN (default: None)
  -o OUTFILE   name of the output netCDF file (default: outfile.nc)
  -r FILE,VAR  refdata from netCDF file (default: None)
  -s           split output to yearly netCDF files (default: False)
  -S           make passed config (-c) the new default (default: False)
  -v           increase output verbosity (default: False)
  -y YEARS     range of years to consider (default: 2000-2015)
Package: ldns-explorer
LDNS ExplorerThis explorer is executed on a client machine to measure performance implications
of choosing a DNS resolver (“LDNS — Local Domain Name Server”) among various
alternatives including the ISP-provided resolver and
several public resolves, namely, Google, OpenDNS,
Cloudflare and Quad9.This work was supported in part by NSF through grant CNS-2219736InstallationVisithttps://pypi.org/project/ldns-explorer/UsageYou can invoke the explorer anywhere by the following command.python3-mldns-explorerCustomized Test CaseWe support customized lists of test domains and resolvers beside our
sample test cases.If you would like to add domains, please create a
txt file calleddomains.txtunder the directory you invoke the
explorer.The file structure is one domain per line.domains.txt:example1.com
example2.comIf you would like to add DNS resolvers, please create a
txt file calledresolvers.txtunder the directory you invoke the
explorer.The file structure is one domain per line.resolvers.txt:0.0.0.0
1.1.1.1DisclaimerThe purpose of this project is twofold. On one hand, we hope it will help Internet
users choose a DNS resolver that would improve their own Web browsing experience. On the
other hand, we would like to obtain general insights about performance
of DNS resolution infrastructures, which may lead to improvements of the Internet
for everybody. For the latter purpose, the DNS Explorer will send the result
of the measurement to us. No personally identifiable information is collected
or accessed by the application -- only the public IP address and the performance metrics. You can disable this
functionality by typingNOto the corresponding prompt during the application
execution; however, we hope you choose to participate in this crowdsourced data collection
in recognition of our effort in creating this application.
Package: ldpatch
This project aims at implementing patch format for Linked Data,
as specified athttp://www.w3.org/TR/ldpatch.It was first inspired by theRDF-Patchproposal,
but it aims at being able to cope with most RDF graph
without relying on bnode identifiers.Thanks... toAlexandre BertailsandAndrei Sambrafor their help on this project.
Package: ldpc
LDPCThis module provides a suite of tools for building and benmarking low density parity check (LDPC) codes. Features include functions for mod2 (binary) arithmatic and a fast implementation of the belief propagation decoder.DocumentationThe full documentation can be foundhere.Installation from PyPi (recommended method)Installtion fromPyPirequires Python>=3.8.
To install via pip, run:pip install -U ldpcInstallation (from source)Installation from source requires Python>=3.6 and a local C compiler (eg. 'gcc' in Linux or 'clang' in Windows). The LDPC package can then be installed by running:git clone https://github.com/quantumgizmos/ldpc.git
cd ldpc
pip install -e ldpcDependenciesThis package makes use of themod2sparsedata structure from Radford Neal'sSoftware for Low Density Parity Check CodesC package.AttributionIf you use this software in your research please cite as follows:@software{Roffe_LDPC_Python_tools_2022,
author = {Roffe, Joschka},
title = {{LDPC: Python tools for low density parity check codes}},
url = {https://pypi.org/project/ldpc/},
year = {2022}
}If you have used the BP+OSD class for quantum error correction, please also cite the following paper:@article{roffe_decoding_2020,
   title={Decoding across the quantum low-density parity-check code landscape},
   volume={2},
   ISSN={2643-1564},
   url={http://dx.doi.org/10.1103/PhysRevResearch.2.043423},
   DOI={10.1103/physrevresearch.2.043423},
   number={4},
   journal={Physical Review Research},
   publisher={American Physical Society (APS)},
   author={Roffe, Joschka and White, David R. and Burton, Simon and Campbell, Earl},
   year={2020},
   month={Dec}
}
Package: ldplayer
LDPlayerThis is package for LDPlayer emulator control software. (unofficial)LDPlayer CLI details can be found inhereTable of contentsLDPlayerInstallUsageEnvironmentsLicenseInstallpipinstallgit+https://github.com/sinmentis/ldplayer.gitUsagefromldplayerimportLDPlayerldplayer=LDPlayer(r"D:\LDPlayer\LDPlayer9\ldconsole.exe")print(ldplayer.list_instances())EnvironmentsLDPlayer 9.0.66Python 3.11LicenseMIT
Package: ld-plot
LD plotPlot of a Linkage Disequilibrium (LD) matrix in PythonInstallationpippip install ld-plotUsagefromld_plot.ld_plotimportld_plot# LD: A symmetric LD matrix# labels: A list of position namesfigure=ld_plot(ld=LD,labels=labels)figure.savefig('ld_plot.png')Example output
Package: ldproto
Length-Delimited ProtoWhen protobuf messages are either across the wire, or put in intermediary storage, it is helpful to be able to read and write individual messages in a streaming format.This package exposes two methods:write_ld(writer, protomsg)- writes one instance of a protobuf message to the streamread_ld(reader, msgtype) -> protomsg- reads one protobuf message from the stream, using the type as the constructorThis package uses an unsigned 32-bit integer as the length-prefix.ExampleAssuming there is a protobuf message with the type name "User"fromldprotoimportread_ld,write_ldimportmyprotoaspb# .ld is for length-delimitedwithopen('out.user.ld','wb')asf:foruserinusers:write_ld(f,user)pb_users=[]withopen('out.user.ld','rb')asf:forpb_userinread_ld(f,pb.User):pb_users.append(user)To write to / from a bytestream in-memory, use BytesIO in-place of the files in the example.
Package: ldrand
A basic linker wrapper that randomizes the link order. This can be used for compiling benchmarked programs to
reduce the impact of specific link orders on the benchmarking results.Not all linking orders might work, due to dependencies, thereforeldrandcurrently tries a new linking order
until it succeeds (or the maximum number of tries is reached which is current set to 10 but can be configured
via the environment variableLDRAND_TRIES).Installationpip3installldrandUsageCalling theldrandpcommand returns the path of thebinfolder that contains the script that masks theldtool. Setting the wrapped linker explicitly is supported by setting the environment variableLDRAND_LINKER.A typical usage would look like:PATH="`ldrandp`:$PATH"make# Or with an explicit linkerPATH="`ldrandp`:$PATH"LDRAND_LINKER="/usr/bin/custom_linker/ld"makeContributingBug reportsandCode contributionsare highly appreciated.