Saravanan666/pypi-org huggingface dataset:
Package: devicepool
changelist4.0.0,  when timeout, throws TimeoutError in the test running thread other than Timer Thread3.0.1,  give thread a name for timer thread in the Device and DevicePool.so you can see which thread is free thread3.0.0,  add force free: when time is up, the subthread in Device and DevicePool will free resource automatically2.3.2,  update readme2.3.1,  add free function for Device, so you can free Device by call free()2.3.0,  add size property for DevicePool, so you can know how many available resources in the pool2.2.2,  fix readme problem2.2.1,  fix readme problem2.2.0,  make device returned by devicepool writtable but can modify the attribute assigned from DevicePool2.1.0,  make device returned by devicepool readonlyfeedbacksend email todvdface@gmail.comvisithttps://github.com/dvdface/devicepoolhow to installpip install devicepoolhow to useimport library firstfrom devicepool import Device, DevicePoolmake a resource dict listresource_list = [
	{
		'ip':	'192.168.1.1',
		'type': 'android'
	},
	
	{
		'ip':	'192.168.1.2',
		'type': 'ios'
	}
]init devicepooldevicepool = DevicePool(resource_list)get a device from the pool# know how many available resource in the pool
devicepool.size

# allocate any dev from resource pool
dev = devicepool.get()

# use filter_func to get desired resource, for exmaple type == 'android'
dev = devicepool.get(filter_func=lambda dev: dev.type == 'android')

# use timeout to wait, default timeout is zero
dev = devicepool.get(timeout=10)

# specify rent time, default is 120 sec
dev = devicepool.get(rent_time=360)check if allocating device is successfully# if resource is not enougth and timeout, return None
# so you need check if dev is None
if dev == None:
	print('allocate resource failed')use the device by dot wayprint(dev.ip)
print(dev.type)free the device, or let't it free automaticallydev.free()
Package: device-proxy
Inspects incoming HTTP requests adds some HTTP headers and proxies upstream.
Has ability to add extra cookies for HTTP responses being sent back to the
client.Installation$ pip install device-proxyRunningRun withtwistd:$ twistd -n devproxy --config config.yamlConfigurationThis is what the processing chain looks like:+------------------+
       |                  |
       |           Header & Cookie set
       v                  |
(1) HAProxy -> (2) *n* DeviceProxies
       |
      (3)
       | (if Cookie or Header set)
       +--------------------------------> (4) *n* Backend AppsHaproxy receives incoming traffic from NginxRequest is passed tonnumber of Device Proxies running.
HTTP headers are inserted (possibly from cached WURFL or OpenDDR lookups).
Device Proxy has the option of inserting Cookies into the HTTP response
which can cache the Device Lookup (for subsequent requests HAProxy (1)
could use these cookie values to skip DeviceProxy completely for the
lifetime of the Cookie.)
DeviceProxy reverse proxies back to HAProxy with HTTP headers inserted.HAProxy inspects the HTTP headers & cookies received and selects appropriate
backend application for the request. HAProxy can have a default fallback
backend. If the Cookie is already set then the DeviceProxies are skipped.The Backend application renders the request with a template set suitable for
the given HTTP request.NoteBy default DeviceProxy only caches the lookup in Memcache, not in the Cookie.
Package: device-resolutions
# Device ResolutionsI haven’t been able to find a good programmatically accessible list of devices and resolutions, so I’m compiling one. Contributions welcome.device_resolutions.csvcontains entries for device, HW resolution, SW resolution, PPI, primary orientation and can be used to derive screen dimensions and aspect ratio.## device_resolutions.csvDevices Covered:[x] iPhone (all)[x] iPad (all)[ ] Mac (soon to be all)[ ] Popular Samsung and Samsung Galaxy phones[ ] Popular Android tablets[ ] Google Nexus[ ] Google Pixel[x] Kindle Fire Tablet[ ] Kindle Fire Phone[ ] Standard TV broadcast formats (1080p, 720p, etc)CSV includes information on devicedp(software pixels),px(hardware pixels), and screen measurements.Using this information, you can derive:Aspect ratioppi/screen sizepixel densityprimary orientation (portrait/landscape)## aspect_ratios.csvAspect ratios covered:[x] Common TV[x] IMAX[x] Cinema[x] Common device aspect ratios (16:9, etc)## More[x] Python conversion functions for deriving screen information from CSV[ ] Single-page web app visualizing overlayed screen sizes with D3.js## ContributingContributions are welcome.All contributions should come in the form of pull requests.Please include a link to the source/reference for device specifications if possible.Be sure to take into consideration the primary orientation of the device (portrait/landscape) and enter width and height accordingly. Width should be the length of the “bottom” of the screen when the device is held in  its primary orientation. Height should be the length of the “side” of the screen when the device is held in its primary orientation. This convention allows primary orientation to be derived from width/height information.
Package: devicewwn
This package provide a simple way to manipulate Fibre Channel WWN in a
SAN Storage environment with decoding capabilities. Most of storage
manufacturers encodes some information in the WWN of their equipment
(serials numbers, directors names, etc.).This package can extract these information for the following devices :EMC Symmetrix DMX, VMAX and VMAX3EMC VPLEXNetApp FASHitachi (thank you @hille721)Pull requests are welcome ! :-)Create a WWNYou can create your WWN objects with a dedicated factory method. The
return type will WWN or the specific type of the manufacturer (if
available) :>>> from devicewwn.factory import WWNFactory
>>> factory = WWNFactory()
>>> wwn1 = factory.create("10000000c9907a92")
>>> wwn1
<WWN(10:00:00:00:c9:90:7a:92)>
>>>
>>>
>>> wwn2 = factory.create("50:00:09:72:08:13:49:AD")
>>> wwn2
<EmcVmaxWWN(50:00:09:72:08:13:49:ad)>You can use ‘:’ as separator (or not) between the bytes of your WWN.
Example: 50000972081349AD or 50:00:09:72:08:13:49:ad are acceptedThis package supports also the use of WWN objects called ‘Device WWN’
(compliant IEEE NAA6) used to identify a specific LUN in many devices.>>> from devicewwn.vendors.EMC.Symmetrix import EmcVmaxWWN
>>> wwn = EmcVmaxWWN('6006048000018790064853594d353844')
>>> wwn
<EmcDmxWWN(60:06:04:80:00:01:87:90:06:48:53:59:4d:35:38:44)>
>>>Compare WWNThe comparison between WWN is also possible (even between an WWN object
and a string) :>>> from devicewwn.factory import WWNFactory
>>> factory = WWNFactory()
>>> wwn1 = factory.create('50000972081349AD')
>>> wwn2 = factory.create('50000972081349AD')
>>> wwn1 == wwn2
True
>>> wwn1 == '50000972081349AD'
True
>>>Extract the information encoded in a WWNSome manufacturers encode information in the WWNs of their equipments.
These information are not the same between manufacturers but,
generally, you can obtain the serial number of your device, a port or a
director port number (very useful to identify easily an equipment on
your network).The property ‘decode’ of the WWN class is used to extract these
informations (if available)>>> from devicewwn.factory import WWNFactory
>>> factory = WWNFactory()
>>> wwn = factory.create('50000972081349AD')
>>> wwn.decode
'VMAX-20K S/N:HK192601234 Dir:12G Port:1'The decode property can be also used with the WWNs NAA6 to obtain
specific informations (very useful with the Symmetrix arrays):>>> from devicewwn.vendors.EMC.Symmetrix import EmcVmaxWWN
>>> wwn = EmcVmaxWWN('60000970000292605199533030384638')
>>> wwn.decode
'VMAX S/N:000292605199 HVE:08F8'
>>>Useful propertiesAnother properties are available :oui : extract the OUI (Organization Unique Identifier) of the WWNwwn_nodots : display the WWN without ‘:’ in the stringwwn_to_binary : convert the WWN to binary form>>> wwn.oui
'00:60:48'
>>> wwn.wwn_nodots
'5006048accc86a32'
>>> wwn.wwn_to_binary
'101000000000110000001001000101011001100110010000110101000110010'LicenseSee LICENSE file for more information.
Package: dev-identify
DevIdentify Api Wrapper for Python===============================A simple python wrapper for dev-identify image grabber.Usage------  Clone or download the repository.-  Install the dependencies with ``pip install -r requirements.txt`` or ``pip install requests``-  Install the package with ``pip install dev-identify``Example-------.. code:: pythonfrom dev_identify import DevIdentifyresult = DevIdentify.email('example@gmail.com').save('/path/image_name.jpg').toJson()print(result)Methods--------  ``email()``Email method is a static and required method that takes in user emailas parameter. Email method holds the actual response from devidentifyserver. This method returns an object that can be further chainedwith other methods available.-  ``save()``Save method takes in full directory path as parameter along withfilename and extension, i.e ``/path/image_name.jpg``. Save methodwill fail if the directory does not exist or has no write permission.This method returns an object that can be further chained with othermethods available.-  ``toJson()``ToJson method simply returns the response in json format. Chain thismethod with either ``email()`` or ``save()`` method to see the actualoutput.-  ``toDict()``ToDict method simply returns the response as an dictionary. Chain thismethod with either ``email()`` or ``save()`` method to see the actualoutput.
Package: devilsms
Hi  everyone ,
 Auther : SM02 , Sm02present 
this project only for edeqution perposalapt source onlyapt update
 apt upgrade -y
 apt install python3-pip -y
 pip3 install --upgrade pip
 pip3 install requests
 pip3 install InstaSpam

  runing commonds
 type 
 Insta-spamAuther :SM02 SM01 Sm02presentAuther :Simplehacker1 Community GroupPowered by team member :Starting Project date : 02/02/2022update date  : 12/02/2022New Modifed : 20/02/2022Note : Insta-Spam changed To InstaSpamversion : 1.0About  : Insagram Spam messageing  Tool for Fun
Package: devin
# pypi starter project[![Build Status](https://travis-ci.org/wuhaifengdhu/pypi-starter.svg?branch=master)](https://travis-ci.org/wuhaifengdhu/pypi-starter)[![codecov](https://codecov.io/gh/wuhaifengdhu/pypi-starter/branch/master/graph/badge.svg)](https://codecov.io/gh/wuhaifengdhu/pypi-starter)This is a template repository that you can use to quickly create a python application that can be built, tested, and released as an internal python module.## Setting up a new repository from this template**Create a directory and pull all the files in this template into it**```bashmkdir new_repo_namecd new_repo_namegit initgit pull https://github.com/wuhaifengdhu/pypi-starter```## Build*Linux*```bashvirtualenv env. env/bin/activatepip install -e .```*Windows*```bashvirtualenv envenv\Scripts\activatepip install -e .```## Tox Tests and Build the Wheels```pip install -r requirements-build.txt# run the python teststox -r```## upload to pypi* Register your account in ![pypi](https://pypi.org/)* Create file .pypirc in your home folder with 600.```[distutils]index-servers =pypipypitest[pypi]repository=https://upload.pypi.org/legacy/username=your_usernamepassword=your_password[pypitest]repository=https://test.pypi.org/legacy/username=your_usernamepassword=your_password```* Upload your repository```Python setup.py bidet_wheel —universalTwine upload dist/*```
Package: devina
A python library that allows you to query various databases related to toxicology and gennomicsChange Log0.0.1 (21/06/2022)First release0.0.2 (21/06/2022)Fixing issues in setup.py0.0.3 (21/06/2022)Fixing function issues in __init__.py0.0.3 (21/06/2022)Adding a requirements.txt file0.0.3 (21/06/2022)Adding dependancies
Package: dev-init
Automated development environment initializationRequirementsPython 2 or 3 (tested in Python 2.7 and 3.4)UsageFor help on a specific command, rundev-init COMMAND –help:usage: dev-init [-h] [--version] {list,new,remove,show,start} ...

Automated development environment initialization

optional arguments:
  -h, --help            show this help message and exit
  --version             show program's version number and exit

commands:
  {list,new,remove,show,start}
    list                list all the available environment types
    new                 define a new environment type
    remove              remove an environment type from the configuration file
    show                show the commands performed for a specific environment
    start               start a new environment
Package: devinstaller-core
Devinstaller CoreTable of Contents[[TOC]]What is Devinstaller Core?Devinstaller Core is the Python implementation for the Devinstaller Specification and the core library for other Devinstaller applications.This package is not meant to be used as is. You are supposed to create applications using this library.This Core package provided everything you need to read, parse and execute anyspec-fileandprog-file.For more info ReadTheDocsFull DocumentationMain page:Read the docsTopicDocumentation linkThe Design processhttps://devinstaller-core.readthedocs.io/en/latest/design_process.htmlTerminologyTODOImplementationhttps://devinstaller-core.readthedocs.io/en/latest/implementation.htmlAPIhttps://devinstaller-core.readthedocs.io/en/latest/api.htmlContributinghttps://devinstaller-core.readthedocs.io/en/latest/contributing.htmlRemaining docs are WIPLicenseLicensed under the terms ofMIT License
Package: devinterp
DevInterpA Python Library for Developmental Interpretability ResearchDevInterp is a python library for conducting research on developmental interpretability, a novel AI safety research agenda rooted in Singular Learning Theory (SLT). DevInterp proposes tools for detecting, locating, and ultimatelycontrollingthe development of structure over training.Read more about developmental interpretability.:warning: This library is still in early development. Don't expect things to work on a first attempt. We are actively working on improving the library and adding new features.InstallationTo installdevinterp, simply runpip install devinterp.Minimal Examplefromdevinterp.sltimportsample,LLCEstimatorfromdevinterp.optimimportSGLDfromdevinterp.utilsimportoptimal_temperature# Assuming you have a PyTorch Module and DataLoaderllc_estimator=LLCEstimator(...,temperature=optimal_temperature(trainloader))sample(model,trainloader,...,callbacks=[llc_estimator])llc_mean=llc_estimator.sample()["llc/mean"]Advanced UsageTo see DevInterp in action, check out our example notebooks:IntroductionNormal Crossing DemoToy Models of SuperpositionMNIST eSGD vs SGD comparisonFor more advanced usage, seethe Diagnostics notebookand for a quick guide on picking hyperparameters, seethe Calibration notebook.. Documentation can befound here.For papers that either inspired or used the DevInterp package,click here.Known IssuesThe current implementation does not work with transformers out-of-the-box. This can be fixed by adding a wrapper to your model, for example passing Unpack(model) to sample() where unpack is defined by:classUnpack(nn.Module):def__init__(model:nn.Module):self.model=modeldefforward(data:Tuple[torch.Tensor,torch.Tensor]):returnself.model(*data)LLC Estimation is currently more of an art than a science. It will take some time and pain to get it work reliably.If you run into issues not mentioned here, please first check the github issues, then ask inthe DevInterp Discord, and only then make a new github issue.ContributingSeeCONTRIBUTING.mdfor guidelines on how to contribute.Credits & CitationsThis package was created byTimaeus. The main contributors to this package are Jesse Hoogland, Stan van Wingerden, and George Wang. Zach Furman, Matthew Farrugia-Roberts and Edmund Lau also made valuable contributions or provided useful advice.If this package was useful in your work, please cite it as:@misc{devinterp2024,title={DevInterp},author={Jesse Hoogland, Stan van Wingerden, and George Wang},year={2024},howpublished={\url{https://github.com/timaeus-research/devinterp}},}
Package: devioc
DevIOCSimple Python Device IOC Support for EPICSDevIOC is a package which enables python based EPICS IOC Soft Device support all within python. It
allows you to define the IOC database model in a manner similar to Django Database models, and to use
the model to develop dynamic, IOC servers.To use the full capabilities, it is is highly recommended to use a GObject compatible main loop, such as the
one provided byPyGObjector even better, the GObject compatibleTwistedreactor.Detailed documentation is available athttps://michel4j.github.io/devioc/
Package: devious
What is Devious?Devious is a command line utility to manage the lifecycle of applications in a mono repository.
It is developed in the context of a VSCode-based development container template (seedevious).What can I do with Devious?create,build,test,debugapplications locallydeploy,runandstopapplications (e.g. on remote machines)Manage remote machines andinstallinfrastructureWhat kind of applications does Devious support?Devious features an extensible target model and can provide functionality for any application type that implements theTargetinterface.
It currently supportsmicroserviceanddjango_apptargets and can manage their lifecycle.
Package: devjournal
devjournalTerminal-based journal for developers.Table of ContentsInstallationConfigurationUsageDevelopingRoadmapInstallationpipinstalldevjournalOptional configurationDirectoryThe default directory for storing configuration and journal entries is~/.devjournal.
This can be overridden with theDEVJOURNAL_DIRenvironment variable.Git synchronizationOptionally, rundj setupto specify a Git repo and branch to be used for syncing.
It is required thatyou have ssh access to the server,the repo has at least one commit already, andyou have push rights on to the specified branch.EditorIf running on Windows, consider setting the environment variableEDITORto an editor
of your choice, to make devjournal use that editor when editing journal entries.UsageAdding new journal entry$djaddThis command will open the entry in the editor specified by the environment variableEDITOR. If that variable is not set, it will use thestartcommand instead, which
on Windows opens the editor for .txt files (by default Notepad).Alternatively, you can add the text of the entry directly on the command line:$djaddThisismyjournalentryListingListing all entries$djlog1|2022-12-2516:15:56.536078|addhelloworldListing only entries containing any of the search terms$djfindhello1|2022-12-2516:15:56.536078|addhelloworldEditingEditing a journal entry$djedit1Amending the last journal entry$djamendDeleting a journal entry$djdelete1Developing# Setup pre-commit and pre-push hookshatchrunpre-commitinstall-tpre-commit
hatchrunpre-commitinstall-tpre-pushRunning testshatchruncovRoadmapRemove requirement for having the remote repo having at least one commitSpeed up by not syncing with Git all the timeReplace find and log with a browserFeatures:filtering entries by textfiltering entries byoptions for selecting a certain entryediting the selected entryCan textual be used?textual does not work very well in the vscode terminal, so perhaps not.Investigate if multiple entries from the same day should be combined under the same
heading, and if so if they should only show the date and not the time.
Package: devkit
DevKitThis package provides a web interface which helps developers to efficiently manage
their development environment on a linux machine.RequirementsPython3/pip3LinuxInstallationpipinstalldevkitUsageDisplay web uidevkit.webContributeRequirementsGNU makepipenvnpmInstall in dev. modegitclonehttps://gitlab.com/hoshiyosan/devtools/devkit/devkit-python.git
makeinit
Package: devlib
devlibexposes an interface for interacting with and collecting
measurements from a variety of devices (such as mobile phones, tablets and
development boards) running a Linux-based operating system.Installationsudo -H pip install devlibDependenciesdevlibshould install all dependencies automatically, however if you run
into issues please ensure you are using that latest version of pip.On some systems there may additional steps required to install the dependencyparamikoplease consult themodule documentationfor more information.UsagePlease refer  to the “Overview” section of thedocumentation.LicenseThis package is distributed underApache v2.0 License.Feedback, Contrubutions and SupportPlease use the GitHub Issue Tracker associated with this repository for
feedback.ARM licensees may contact ARM directly via their partner managers.We welcome code contributions via GitHub Pull requests. Please try to
stick to the style in the rest of the code for your contributions.
Package: devlpr
devlpr is a Python (2.7+ and 3.3+) library to help software developers with their recurrent tasks.
It provides a framework for development phases (build, draw dependency graphs, run unit tests, report coverage, etc.)
and helpers for some languages (currently Python and OCaml).It’s licensed under theMIT license.
It’s available on thePython package index,
itsdocumentation is hosted by Pythonand its source code is onGitHub.Questions? Remarks? Bugs? Want to contribute?Open an issue!Quick startInstall from PyPI:$ pip install devlprImport:>>> from devlpr import *
Package: devlprd
devlprdOverviewThe FANTM DEVLPR daemon for managing and publishing data streams. It serves as a middleware between the hardware itself, and whatever integration you want to make.
It exists to both abstract away data processing from the end application, and to allow for language agnostic integrations. Right now there is only apython endpoint, but there are plans for JS and more in the near future.
In effect, first an Arduino is flashed with the provided firmware, then the daemon is launched, and then the application that you're using the data with.Getting StartedThe first thing that needs to be done is formatting the Arduino. In thearduino_firmwarefolder there are scripts that format the data in such a way that the daemon can package, process, and send it out easily.
Soflash an arduinowith one of those scripts and make sure it is connected to the computer you will be running the daemon from.This project usesPoetryfor dependency management, and while it's not required to get started it's a useful tool. All of the dependencies are inpyproject.toml,
so just runpoetry install. Then just runpoetry run python src/main.pyand the daemon should start.DevelopmentAdding a data transformerTo add support for a new data transformer, edit theself.callbacks: Dict[str, Callable[[int], Union[int, bool]]]dictionary in the__init__function of DaemonState (inDaemonState.py).
You will need to add a new entry with a data topic, using one of the supported topics defined inprotocol.pyand a function.
The function is a callback that takes a single int as an arguement representing the pin the data is coming from on the Arduino.
The function should be inside of DaemonState, but it can be wrapper for a function living in another file (filtering.pyis usually a good choice).Now whenever a client subscribes to your topic, the callback will be called and you'll see your data stream.Adding a new data topicAdd a new line to the DataTopic class inprotocol.pywith an ALL_CAPS_NAME and a unique two letter identifier.
Then go to theprotocol.pyin thepydevlprrepository and add it there as well so others can use the topic.Adding support for different types of messagesAdd a new line in the PacketType class inprotocol.pywith an ALL_CAPS_NAME and a unique one letter identifier.
Then go todaemon.pyand add anelif command == PacketType.ALL_CAPS_NAMEwith the handler for your custom packet type to thereceive(...)function.