Saravanan666/pypi-org huggingface dataset:
Package: diskannpy
diskannpyInstallationPackages published to PyPI will always be built using the latest numpy major.minor release (at this time, 1.25).Conda distributions for versions 1.19-1.25 will be completed as a future effort.  In the meantime, feel free to
clone this repository and build it yourself.Local Build InstructionsPlease see theProject READMEfor system dependencies and requirements.After ensuring you've followed the directions to build the project library and executables, you will be ready to also
builddiskannpywith these additional instructions.Changing Numpy VersionIn the root folder of DiskANN, there is a filepyproject.toml. You will need to edit the version of numpy in both the[build-system.requires]section, as well as the[project.dependencies]section.  The version numbers must match.Linuxpython3.11-mvenvvenv# versions from python3.9 and up should worksourcevenv/bin/activate
pipinstallbuild
python-mbuildWindowspy-3.11-mvenvvenv# versions from python3.9 and up should workvenv\Scripts\Activate.ps1pipinstallbuildpython-mbuildThe built wheel will be placed in thedistdirectory in your DiskANN root. Install it usingpip install dist/<wheel name>.whlCitationsPlease cite this software in your work as:@misc{diskann-github,
   author = {Simhadri, Harsha Vardhan and Krishnaswamy, Ravishankar and Srinivasa, Gopal and Subramanya, Suhas Jayaram and Antonijevic, Andrija and Pryce, Dax and Kaczynski, David and Williams, Shane and Gollapudi, Siddarth and Sivashankar, Varun and Karia, Neel and Singh, Aditi and Jaiswal, Shikhar and Mahapatro, Neelam and Adams, Philip and Tower, Bryan and Patel, Yash}},
   title = {{DiskANN: Graph-structured Indices for Scalable, Fast, Fresh and Filtered Approximate Nearest Neighbor Search}},
   url = {https://github.com/Microsoft/DiskANN},
   version = {0.6.1},
   year = {2023}
}
Package: diskbackup
diskbackupdiskbackupis a very simple backup tool. Main features:The directorydestwill be a clone ofsrc(and its subdirectories). New files or modified files will be copied, and files indestwhich are not insrcwill be removed.The backup is incremental: only new or modified files will be copied.filename+file size+modification timeare used to do the comparison between source and destination files.Supports exclude patterns (case insensitive)Follows symbolic linksWorks when thedestis a network shared folder (tested on Windows)The source code is ~50 lines of code: you don't even need to scroll in your text editor to read the code, it takes only one page ;)Installation and usageYou need Python 3.6+, and to do:pip install diskbackup(An alternative installation method is to just copy the single filediskbackup.pywhere you want to use it.)This is how to use it:from diskbackup import backup
backup(src=r'd:\docs', dest=r'i:\docs')                  
backup(src=r'd:\docs', dest=r'i:\docs', fake=True)   # fake run, no change on destination
backup(src=r'd:\docs', dest=r'i:\docs', exclude=['excluded_dir', '.mp4'])   # the src file list will ignore these patterns
backup(src=r'd:\docs', dest=r'i:\docs', exclude=['excluded_dir', '.mp4'], excludefromdest=True)  # the src and dest file lists will ignore these patternsAuthorJoseph ErnestLicenseMIT
Package: disk-bench
Designed to run similar tests as Crystal Disk Mark using fio with user friendly output options.Tests ran:Sequential read/write w/ 1MB block sizeRandom read/write w/ 512K block sizeQueue depth 32 random read/write 4K blocks sizeInstall# system install
$ sudo pip3 install disk-bench

# user install
$ pip3 install --user disk-benchUsage$ disk-bench --help

# Default runs fio w/ --loops=3 and --size=1G
$ disk-bench /mnt/disk-to-test/whatever

# Show CSV output (for easy copy/paste into Excel or Google Sheets)
$ disk-bench /mnt/disk-to-test/whatever --style=csv

# Quick
$ disk-bench /mnt/disk-to-test/whatever --loops=1 --size=1MCommand DetailsThefiocommand we are running is essentially:fio –directory . –filename=disk~bench.tmp –output-format=json –stonewall –ioengine=libaio –direct=0 –gtod_reduce=1 –name=seqread –bs=1m –rw=read –size=64G –name=seqwrite –bs=1m –rw=write –size=64G –name=randread –bs=512k –rw=randread –size=4G –name=randwrite –bs=512k –rw=randwrite –size=4G –name=4kQD32read –bs=4k –iodepth=32 –rw=randread –size=4G –name=4kQD32write –bs=4k –iodepth=32 –rw=randwrite –size=4G –name=4kQD16 –bs=4k –iodepth=32 –rw=randrw –rwmixread=65 –size=4GChangelog0.2.1 released 2018-12-22add fio command example to readme (d4f6bef)add direct flag back (578f509)0.2.0 released 2018-12-21change tests we run and output format (df6ac7b)0.1.4 released 2018-12-21fix cli direct flag (74aa304)0.1.3 released 2018-12-21support non-direct IO (f5ba899)0.1.2 released 2018-12-20fix some packaging issues (f908a1d)0.1.1 released 2018-12-20fix pypi name (10d6115)0.1.0 released 2018-12-20add tox & CI (12cfca5)fix json bytes/text for Python 3.5 (475e3ee)add tox improve package (ee8efc4)
Package: diskcache-fernet
diskcache-fernethow to install$pipinstalldiskcache-fernethow to usefrom__future__importannotationsfrompathlibimportPathfrompickleimportUnpicklingErrorfromtempfileimportTemporaryDirectoryfromdiskcacheimportCachefromdiskcache_fernetimportFernetDiskdefmain(temp:Path)->None:origin=Cache(temp)fernet=Cache(temp,disk=FernetDisk)# or add fernet key# fernet = Cache(temp, disk=FernetDisk, disk_fernet=b"some fernet key")fernet["string"]="value"fernet["pickle"]={"key":"value"}from_fernet_string=fernet["string"]from_origin_string=origin["string"]assertfrom_fernet_string!=from_origin_stringassertfrom_fernet_string=="value"print(from_origin_string)# like:# gAAAAABlGtPWAPEcYLqu6waiUd551H4jfAvQlulWnfwyWTVtjZyF6AkUCVFQKPpIRz9vu29y1FoduIYoK-mOz5CJt0Kx-pv2zQ==from_fernet_pickle=fernet["pickle"]assertfrom_fernet_pickle=={"key":"value"}try:origin["pickle"]exceptExceptionasexc:assertisinstance(exc,UnpicklingError)if__name__=="__main__":withTemporaryDirectory()astemp:main(Path(temp))LicenseApache-2.0, seeLICENSE.
Package: diskcsvsort
Disk CSV SortDescriptionSort huge CSV files using disk space and RAM together.For now support only CSV files withheader.UsageFor exampleCSV file with moviesnameyearBatman Begins2005Blade Runner 20492017Dune2021Snatch2000Sort this CSV file that stored inmovies.csvbyyearandname.Note:order of columns is matter during sorting.Using diskcsvsort packagefrompathlibimportPathfromdiskcsvsortimportCSVSortcsvsort=CSVSort(src=Path('movies.csv'),key=lambdarow:(int(row['year']),row['name']),)csvsort.apply()Using diskcsvsort CLIpython -m diskcsvsort movies.csv --by year:int --by name:strNote: columnsyearandnamewill be converted tointandstr, respectively.Available types:strintfloatdatetimedatetimeTypes usage:str:column:strint:column:intfloat:column:floatdatetime:column:datetime(%Y-%m-%d %H:%M:%S)date:column:datetime(%Y-%m-%d)time:column:datetime(%H:%M:%S)AlgorithmTODOMetricsTODO
Package: disk-detective
DescriptionProvides tools to analyze disks on byte levelAvailable ToolsMaster Boot Record ExaminerProvides information and analysis of MBRFAT ExaminerProvides information and analysis of:FAT VBRFAT FSInfoFAT Directory EntryFAT Long FilenameUnder ConstructionDisk Usage InformationOverview of disk space usage based on MBR informationFuture ToolsExtended Partition AnalyserExamines extended parititionsFile System AnalyserextNTFSInstallationpip install disk_detectiveUsageFrom command line:python -m disk_detective --path PATH --mode {mbr,structure,fat-vbr,fat-fsinfo,fat-lfn,fat-dir-entry} [--offset OFFSET]OptionShortTypeDefaultDescription--path-pString-Path to file (dd, raw) orpath to disk (\.\PhysicalDrive0, /dev/sda, /dev/disk1)--mode-pString-mbr = Examines the MBRusage = Overview of disk space usagefat-vbr = Examines FAT VBRfat-fsinfo = Examines FAT FSInfofat-lfn = Examines Long Filename Entriesfat-dir-entry = Examines Directory Entries--offset-oInt-The offset in bytes to start readingExampleOutput for mode == mbrpython -m disk_detective -p path/to/example.dd -m mbrPlease find the resulthereOutput for mode == fat-vbrpython -m disk_detective -p path/to/example.dd -m fat-vbr -o 1048576Please find the resulthereOutput for mode == fat-fsinfopython -m disk_detective -p path/to/example.dd -m fat-fsinfo -o 1049088Please find the resulthereOutput for mode == fat-lfnpython -m disk_detective -p path/to/example.dd -m fat-lfnPlease find the resulthereOutput for mode == fat-dir-entrypython -m disk_detective -p path/to/example.dd -m fat-dir-entryPlease find the resulthereLicenseMIT
Package: disk_dict
DiskDict is a hashtable on your hard drive. It allows you to store KAZILLIONS (!) of key/value pairs and interact with them as you would a Python dictionary, all the while never storing more than two key/value pairs in memory simultaneously. The key/value pairs can be anything that’s serializable (you specify the serializer and deserializer, with repr and eval as the default). Since we’re operating on the disk, big O of all operations are dependent on the host operating system’s file access complexities.>>> from disk_dict import DiskDict
>>> from numpy import array
>>> dd = DiskDict('my_disk_dict')
>>> a = array([[1,2],[3,4]])
>>> dd[a] = 'I was pointed to by ' + repr(a)
>>> dd[a]
'I was pointed to by array([[1, 2],\n       [3, 4]])'
>>> del dd[a]
>>> dd[a]
>>>PyPI:https://pypi.python.org/pypi?name=disk_dict&:action=displayGithub:https://github.com/AWNystrom/DiskDict/
Package: diskhashtree
Disk Hash Tree Python PackageAn implementation for storing and searching through a large set of hashes.What's this for?This project was originally being developed forMLC@homeas a solution to storing and testing membership for a large amounts of hashes in a memory-cheap, fast and persistent data structure. It uses the optimisations of the filesystem to do all the hard work of storing and checking membership of a hash in a set.Why make this?Other than pickling and managing aset()object on-disk with a custom script, I couldn't find any other Python solution to implement a quick, persistentset()-like object that could support big data.At the time of making this, I am studying Advanced Computer Science at Western Sydney Univeristy and was tasked with this as an extra-cirricula activity, so why not turn this into something a little bit bigger?Getting startedThis package can be run standalone or imported into any Python script.Installingpip install diskhashtreeImporting and quickstartfrom diskhashtree import DiskHashTree

dht = DiskHashTree('./mydht/')

dht.add('aaaaaa')
dht.add('zzzzzz')

print(dht.contains('aaaaaa'))

print(dht.pop())

dht.discard('aaaaaa')
dht.discard('zzzzzz')

print(dht.is_empty())Running standaloneDiskHashTree can be run straight from the commandline with no additional overhead compared to running it natively in Python. All the information is in the help function:diskhashtree -hThe mathsI had no idea until I finished this project and started showing it off that I realised this package is in fact an implementation of a radix tree on a file system and had no idea radix trees existed until this point. You can check out the operations and complexity onWikipedia.What I am saying is that this structure is not exactly a radix tree but it is almost exactly the same.
Package: diskimage
About The ProjectA python module that lets you handle disk images in an easy way.Installationpip install diskimageUsageThe tool comes with a commandline clientdithat will let you work with diskimages:usage: di <command> <options> diskimagefile

Get information from disk-images.

positional arguments:
  {fls}          Command to run. "fls" will list full path for all files found in diskimage
  diskimagefile  The diskimage file to open

optional arguments:
  -h, --help     show this help message and exit
  -v, --verbose  Add verbosity, -vv to enable debugging
  --version      Print version information

Example: "di fls test.dd"orYou can also use the available python methods directly from your script:>>>importdiskimageasdi>>>image=di.DiskImage.from_file('split.E01')>>>image.filesystems[<diskimage.filesystem.FileSystemobjectat0x741564ba8580>,<diskimage.filesystem.FileSystemobjectat0x741564ba8100>]>>>[item.nameforiteminimage.get_items()]['$AttrDef','$BadClus','$Bitmap','$Boot','$Extend','$ObjId','$Quota','$Reparse','$LogFile','$MFT','$MFTMirr','$Secure','$UpCase','$Volume','secret.txt','$OrphanFiles','$AttrDef','$BadClus','$Bitmap','$Boot','$Extend','$ObjId','$Quota','$Reparse','$LogFile','$MFT','$MFTMirr','$Secure','$UpCase','$Volume','secret.txt','$OrphanFiles']LicenseDistributed under the MIT License. SeeLICENSEfor more information.ContactJarle Thorsen -@jarlethorsen-jarlethorsen@gmail.comProject Link:https://github.com/jarlethorsen/diskimage
Package: diskimage-builder
Image building tools for OpenStackdiskimage-builderis a flexible suite of components for building a
wide-range of disk images, filesystem images and ramdisk images for
use with OpenStack.This repository has the core functionality for building such images,
both virtual and bare metal. Images are composed usingelements;
while fundamental elements are provided here, individual projects have
the flexibility to customise the image build with their own elements.For example:$ DIB_RELEASE=bionic disk-image-create -o ubuntu-bionic.qcow2 vm ubuntuwill create a bootable Ubuntu Bionic basedqcow2image.diskimage-builderis useful to anyone looking to produce
customised images for deployment into clouds. These tools are the
components ofTripleOthat are responsible for building disk images. They are also used
extensively to build images for testing OpenStack itself, particularly
withnodepool.
Platforms supported include Ubuntu, CentOS, RHEL and Fedora.Full documentation, the source of which is indoc/source/, is
published at:https://docs.openstack.org/diskimage-builder/latest/CopyrightCopyright 2012 Hewlett-Packard Development Company, L.P.
Copyright (c) 2012 NTT DOCOMO, INC.All Rights Reserved.Licensed 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: diskinfo
diskinfoDisk information Python library can assist in collecting disk information on Linux. In more details, it can:collect information about a specific diskexplore existing disks in the systemtranslate between traditional and persistent disk namesread current disk temperatureread SMART data of a diskread partition list of a diskInstallationStandard installation frompypi.org:pip install diskinfoSee the complete list of dependencies and requirements in thedocumentation.DemoThe library contains a demo application with multiple screens (richneeds to be installed):pip install rich
python -m diskinfo.demoSee more demo screens in thedocumentation.API documentationThe detailed API documentation can be found onreadthedocs.io.
Package: diskit
Distibuted QC for QiskitDistributed quantum computing is a concept that proposes to connect multiple quantum computers in a network to leverage a collection of more, but physically separated, qubits. In order to perform distributed quantum computing, it is necessary to add the addition of classical communication and entanglement distribution so that the control information from one qubit can be applied to another that is located on another quantum computer. For more details on distributed quantum computing, see this blog post:Distributed Quantum Computing: A path to large scale quantum computingIn this project, we aim to validate distributed quantum algorithms using Qiskit. Because Qiskit does not yet come with networking features, we embed a "virtual network topology" into large circuits to mimic distributed quantum computing. The idea is to take a monolithic quantum circuit developed in the Qiskit language and distribute the circuit according to an artificially segmented version of a quantum processor. The inputs to the library are a quantum algorithm written monolithically (i.e., in a single circuit) and a topology parameter that represents the artificial segmentation of the single quantum processor.The algorithm takes these two inputs and remaps the Qiskit circuit to the specified segmentation, adding all necessary steps to perform an equivalent distributed quantum circuit. Our algorithm for achieving this is based on the work:Distributed Quantum Computing and Network Control for Accelerated VQE. The algorithm output is another Qiskit circuit with the equivalent measurement statistics but with all of the additional logic needed to perform a distributed version.
Package: disklru
disklrupip install disklruCreates a disk based lru (least recently used) cache, backed by sqlite, that you can use in your apps.Zero dependency package. Only relies on the python standard lib. Cross platform tests.UsagefromdisklruimportDiskLRUCacheLRU_CACHE_FILE="cache.db"MAX_ENTRIES=4cache=DiskLRUCache(LRU_CACHE_FILE,MAX_ENTRIES)cache.put("key","value")assertcache.get("key1")=="val"cache.clear()APIclassDiskLRUCache:"""Disk-based LRU cache using SQLite."""defget(self,key:str)->str|None:"""Returns the value associated with the given key, or None if the key is not in the cache."""defget_json(self,key:str)->Any:"""Returns the value associated with the given key, or None if the key is not in the cache."""defput(self,key:str,value:str)->None:"""Sets the value associated with the given key."""defput_json(self,key:str,val:Any)->None:"""Sets the value associated with the given key."""defdelete(self,key)->None:"""Deletes the given key from the cache."""defpurge(self,timestamp)->None:"""Purges all elements less than the timestamp."""defclear(self)->None:"""Clears the cache."""def__del__(self)->None:"""Destructor."""self.close()defclose(self)->None:"""Closes the connection to the database."""DevelopmentWindowsThis environment requires you to usegit-bash.LintingRun./lint.shto find linting errors usingpylint,flake8andmypy.
Package: diskmap
diskmapis a tool for scattered light mapping of protoplanetary disks. The disk surface is parameterized with a power law profile or read from an input file. The projected radius and scattering angle are then calculated at each pixel. From this, a 3D deprojected image and a stellar irradiation corrected image are computed. Also a polarized scattering phase function is extracted and an total intensity phase function is estimated.DocumentationDocumentation can be found athttp://diskmap.readthedocs.io. There is anotebook tutorialthat demonstrates the usage.AttributionPlease citeStolker et al. (2016b)whenever results fromdiskmapare used in a publication (seearXiv,ADS,BibTeX).ContributingContributions are welcome so please considerforkingthe repository and creating apull request. Bug reports and feature requests can be provided by creating anissueon the Github page.LicenseCopyright 2020-2023 Tomas Stolkerdiskmapis distributed under the MIT License. See the LICENSE file for the terms and conditions.
Package: disk_objectstore
disk-objectstoreAn implementation of an efficient key-value store that writes directly on disk
and does not require a server running.Latest releaseBuild statusGetting helpPerformanceBenchmarksGoalThe goal of this project is to have a very efficient implementation of an "object store"
that works directly on a disk folder, does not require a server to run, and addresses
a number of performance issues, discussed also below.This project targets objects that range from very few bytes up to tens of GB each, with
performance tuned to support tens of millions of objects or more.This project originated from the requirements needed by an efficient repository
implementation inAiiDA(note, however, that this
package is completely independent of AiiDA).How to installTo install, just run:pip install disk-objectstoreThis will also install a simpledostorecommand line utility together with the library itself.DocumentationFor instructions on how to use it, some quick start guide, and more detailed information
on the design of the library and its performance, you can checkthe documentation.
Package: diskord
DiskordThis library is a maintained fork of now archived library,discord.py.A modern and easy to use API wrapper around Discord API written in Python.FeaturesModern, Pythonic API based onasync/awaitConsistent, object oriented & easy to use interfaceProvides full coverage of Discord APIProper and sane ratelimit handlingOptimized in both speed and memoryExtensions support & prebuilt powerful commands handlerInstallationPython 3.8 or higheris required to install this library.Basic InstallationTo install the librarywithoutfull voice support, you can just run the following command:python-mpipinstalldiskordVoice SupportOptionally, To interact with discord's voice API, You would require voice support of this library which you can install like so:python-mpipinstalldiskord[voice]Development VersionYou must have git installed to install development version. Otherwise, you can download the code.$gitclonehttps://github.com/nerdguyahmad/diskord
$cddiskord
$python-mpipinstall-U.[voice]or in short;python-mpipinstallgit+https://github.com/diskord-dev/diskord.gitQuick ExampleHere are some quick examples to give you a quickstart and show off the basic features of the library.Application (Slash) Commandsimportdiskordclient=diskord.Client()@client.slash_command(description='Ping-Pong!')asyncdefping(ctx):awaitctx.respond('Pong!')client.run('token')Legacy (Prefixed) Commandsimportdiskordfromdiskord.extimportcommandsbot=commands.Bot(command_prefix='>')@bot.command()asyncdefping(ctx):awaitctx.send('pong')bot.run('token')You can find more examples in theexamplesdirectory.LinksLatest DocumentationOfficial Discord ServerDiscord APIDeveloper Portal
Package: diskord-invites
diskord-invitesPython library for simple invites tracking.FeaturesVery easy to useUsesdiskordActively maintainedLinksPyPiInstallationYou can easily install it using the python package managerpippip install diskord-invitesQuickstartExample usage (bot is diskord.ext.commands.Bot)fromdiskord_invitesimportTrackertracker=Tracker(bot)bot.add_cog(tracker)@tracker.member_joinasyncdefmember_join(member,inviter,channel):awaitchannel.send(f"{member.name}was invited by{inviter.name}")ContributionsFeel free to open pull requests and improve the library. If you find any issues, please report it.
Package: diskq
DiskQDiskQ is a Python library for persistent queue management. It allows you to store queue data on disk, making it easier
to manage your data and prevent data loss in the event of system crashes or power outages.InstallationYou can install DiskQ using pip:pipinstalldiskqUsagePersistentQueueThe PersistentQueue class is used to create a persistent queue. Here's an example:fromdiskqimportPersistentQueue# create a new persistent queuequeue=PersistentQueue('my_queue.pkl')# add items to the queuequeue.put('item1')queue.put('item2')queue.put('item3')# get items from the queueitem1=queue.get()item2=queue.get()item3=queue.get()PersistentPriorityQueueThe PersistentPriorityQueue class is used to create a persistent priority queue. Here's an example:fromdiskqimportPersistentPriorityQueue# create a new persistent priority queuequeue=PersistentPriorityQueue('my_priority_queue.pkl')# add items to the queue with prioritiesqueue.put((1,'item1'))queue.put((2,'item2'))queue.put((3,'item3'))# get items from the queue in order of priorityitem1=queue.get()item2=queue.get()item3=queue.get()PersistentLifoQueueThe PersistentLifoQueue class is used to create a persistent last-in, first-out (LIFO) queue. Here's an example:fromdiskqimportPersistentLifoQueue# create a new persistent LIFO queuequeue=PersistentLifoQueue('my_lifo_queue.pkl')# add items to the queuequeue.put('item1')queue.put('item2')queue.put('item3')# get items from the queue in reverse orderitem3=queue.get()item2=queue.get()item1=queue.get()LicenseThis project is licensed under the MIT License. See theLICENSEfile for details.