Saravanan666/pypi-org huggingface dataset:
Package: zepu1chr3
Zepu1chr3A Radare2 based Python module for Binary Analysis and Reverse Engineering.How to UseSpecifying a target binaryDescription: You can specify any binary file to analysis you want. It returns a handler for target file.importzepu1chr3zep=zepu1chr3.Binary()target=zep.File("WannaCry.exe")Getting symbols from target binaryDescription: This method will give you what symbols are inside of the target file. It returns an array of symbol information.importzepu1chr3zep=zepu1chr3.Binary()targetzep.File("WannaCry.exe")symbols=zep.GetSymbols(target)Getting imports from target binaryDescription: This method will give you what imports are inside of the target file. It returns an array of import information.importzepu1chr3zep=zepu1chr3.Binary()target=zep.File("WannaCry.exe")imports=zep.GetImports(target)Getting functions from target binaryDescription: This method will give you what functions are inside of the target file. It returns an array of function information.importzepu1chr3zep=zepu1chr3.Binary()target=zep.File("WannaCry.exe")functions=zep.GetFunctions(target)Getting sections from target binaryDescription: This method will give you what sections are inside of the target file. It returns an array of section information.importzepu1chr3zep=zepu1chr3.Binary()target=zep.File("WannaCry.exe")sections=zep.GetSections(target)Disassembling functions or somethings contained in offsetsGetting informations about only machine codeDescription: This method will give you disassembled function codes ifonly_codesparameter set toTrueimportzepu1chr3zep=zepu1chr3.Binary()target=zep.File("WannaCry.exe")disas=zep.DisassembleFunction(target,given_function="entry0",only_codes=True)second=zep.DisassembleFunction(target,given_function="0x401000",only_codes=True)# You can use offsets to!!Getting every information about machine code (verbose!!)Description: If you setonly_codesparameter asFalseyou will get more verbose output.importzepu1chr3zep=zepu1chr3.Binary()target=zep.File("WannaCry.exe")disas=zep.DisassembleFunction(target,given_function="entry0",only_codes=False)Pypi and Other functionalities are coming soon!!
Package: zepusu
A minimalist ZeroMQ pub-sub command line client.Features:Publish messages to 0 through ∞ subscribers.Subscribe to all messages or filter by one or more topics.Exits after receiving a single message or subscribed indefinitely.Built with scripting in mind.Installation$ pip install zepusuExampleBegin by starting a subscriber in follow mode.$ zepusu sub -fPublish a few messages.$ zepusu pub hello world
$ zepusu pub greetings galaxyThe subscriber outputs both messages.$ zepusu sub -f
hello world
greetings galaxyUsageusage:zepusu[-h][--version][-pPORT]{pub,sub}...ZeroMQpub-subcommandlineclientpositionalarguments:{pub,sub}optionalarguments:-h,--helpshowthishelpmessageandexit--versionshowprogram'sversionnumberandexit-pPORT
Package: zequals
## zEquals :)#Because it starts with a z.Because I've heard about it via 'Numberphile'.Because it's awesome.Basic usage:>>> from zequals import *>>> zMul(1345,653)589100If you are thinking : Now what's the use, 1345 times 653 should be 589680....Please take a look here : http://www.youtube.com/watch?v=aOJOfh2_4PEBut it get's better!After installing zequals one could do this :from zequals import z@zdef myAwesomeMathFunctions(x,y,z):d = someWickedCalculus(x,y)f = someOtherWeirdThing(z,x)return d/fThe 'deocration' of your function with the @z decorator will make sure allarguments passed to your function will be 'zequalized'.Real World Example:import mathdef myFunc(a,b):return math.sqrt((a*a) + (b*b))myFunc(1253,3543)# will yield : 3758.03911634778now once we go@zdef myFunc(a,b):return math.sqrt((a*a) + (b*b))myFunc(1253,3543)# will yield 3754.210969031975GitHub Repo : https://github.com/zdevops/zequals
Package: zerial
Zerial is the serialization tool that allows your model classes to be the
Zingle Zource of Truth™ for your project.  Let your model classes take
whatever form or use whatever collection types they need, and just use metadata
to define how that text gets serialized.  With support for variant record
types, you can even evolve your data models over time, and even create
versioned models if need be.Zerial is built on top of the excellentattrslibrary, which makes class
creation and definition in Python very easy and very obvious.  This library
adds abritrarily recursive serialization and de-serialization of complex
data classes.Zerial was inspired because complex applications in spaces where requirements
are hard to define up front call for a unique approach to modeling data.  A
solution has to be flexible enough to accomodate a growing and changing
understanding of the underlying problem domain, while being rigorous enough
to encapsulate these changes to data modules.  External schemas like ORM or
JSON Schema are both inflexible and instrinsically bound to specific data
exchange formats (SQL and JSON) that you may or may not want to actually use.
Implicit schemas, although sufficienty flexible, ultimately fail because they
break separation of concerns, requiring every bit of code that touches data
to understand how to create a validate an entire history of model versions
for that data type.This project aims to allow components to structure their data in a way that is
convenient for people interacting with the code, provided that it can be
destructured into simple types.  The combination ofattrs’ rich support for
defaults and value factories and zerial’s support of variant records,  you can
evolve your data models over time, without breaking your client code or stored
serialized data.FeaturesStucturing and destructuring of model classesSupports rich typing without any runtime dependency on stuff from thetypingmodule, which has deeply inconsistent runtime behaviorModel fields can be simple types or other model classesCollection types can be represented as any kind of Python object, as long as
you can convert it to and from a list or dict with string keys.Variant records permit fields that accept multiple types of data, permitting
extensibility.  Variants with default types allow this to be added at any
point in development (and even permits forversioneddata models).Todo/RoadmapOptional native support for numpy arraysExport of schema definition formats from record classesDebug tools for destructure/restructure failuresWrappers aroundattr.sandattr.ibto make defining models cleanerBetter automated checking and testing tools for serializabilityMore extensive documentationDocumentationThe full documentation is athttp://zerial.rtfd.org.History0.1.0 (2018-10-21)First release on PyPI.
Package: zerigodns
Zerigo DNS - REST API - Python Module===================================The API documentation itself is not provided here. The latest version canbe found online at http://www.zerigo.com/docs/managed-dns/api_11.Requirements------------The following are required to use this library:- A functioning Python 2.3+ environment with HTTP (or HTTPS) access to the internet.- Some working knowledge of the Python language.- A Zerigo DNS account with Dynamic Updates / API Access enabled. (Visithttps://ns.zerigo.com/ and go to Preferences to enable access.)- The Dynamic Update / API key. (Also available on the Preferences page.)Use---Basic Install:$ python setup.py build$ sudo python setup.py installAlternative Install (Manually):Place zerigodns directory in your Python path. Either in your Pythoninstalls site-packages directory or set your $PYTHONPATH environmentvariable to include a directory where the zerigodns directory lives.Both the library (zerigodns) and example usage code (example.py) areheavily commented. They should serve as sufficient reference for this code.Updates-------Visit http://www.bitbucket.org/petersanchez/zerigodns for updates, new versions, andmore.Support-------Python Module:For issues with the Python API module, please use the public issue tracker at therepositories website: http://bitbucket.org/petersanchez/zerigodns/Zerigo Support:Support is generally available via standard Zerigo support options. Seehttp://www.zerigo.com/support for more information. Please note that supportmay be limited based on your choice of Zerigo DNS services.Comments / Suggestions----------------------We always welcome comments, suggestions, and constructive complaints. You canfind several ways to contact me at http://www.petersanchez.com/contact/Copyright & Warranty--------------------All documentation, libraries, and sample code areCopyright 2009 Peter Sanchez <petersanchez@gmail.com>. The library andsample code are made available to you under the terms of the BSD licensewhich is contained in the included file, BSD-LICENSE.The terms here grant you no rights in regard to the Zerigo services. Pleasereference Zerigo's Terms of Service for all legal information regardingZerigo's services.
Package: zerionPy
zerionPyzerionPy is an easy-to-use API wrapper for Zerion Software's iFormBuilder. The goal of this project--along with its sister JavaScript-based library zerionJS--is to get you working with the iFormBuilder API in minutes instead of hours or days. The library takes care of all access token management; all you need to do is supply valid credentials and the library will request and renew access tokens for the duration of its execution.Getting StartedTo begin, install the module.pip install zerionPyAfter the module is installed, import it using the following command in your Python file:fromzerionPyimportIFBWith the module imported, create an API connection with the following line:api=IFB(SERVER,REGION,CLIENT_KEY,CLIENT_SECRET,VERSION)The five parameters listed above are required for every API connection. Below are a list of accepted values for version and region.ParameterValuesVERSION6, 8, 8.1REGIONus, uk, au, hipaa, qaIn addition to these five required parameters, the following optional attributes may be configured in a params object. Below is a list of possible options.NameValuesDescriptionsimple_responsetrue/falsewhen enabled, API calls will return only the response bodyskip_rate_limit_retrytrue/falsewhen enabled, 429 status codes will be returned instead of automatically retriedMaking API CallsThis library is designed to make working with Zerion APIs as easy as possible. Each available command/resource combination is available as a distinct method. Methods are named with the following convention:commandResourceName. For example, a GET request to the profiles resource is namedgetProfiles().Additionally, each method is defined to accept the necessary parameters to properly execute. For example, a GET request to the /records resource will require a profile id as well as page id. A corresponding function call may look like:api.getRecords(12345, 67890)where 12345 is the profile id and 67890 is the page id.Querying a specific resource by ID will generally be done by the singular noun of the resource. For example, a GET request to the /records resource with id1would be namedgetRecord()and the function call could look something like:api.getRecord(12345, 67890, 1).For a full list of API commands, refer to the official iForm API documentationhereHow to ContributeThis library is a work in progress. As Zerion APIs are released, this library will be updated. Additionally, functionalities such as additional safeguards for erroneous function calls and improper parameter values may be added in the future. If you have a suggestion or run into any problems, please submit an Issue.Change LogFebruary 1, 2023 (v1.1.3)Added support forsandboxregionJanuary 31, 2023 (v1.1.2)added support for ZIM/User Management api appsOctober 5, 2022 (v1.1.1)fixed parameter list for copyPage()July 15, 2022 (v1.1.0)Addedstr,repr, anditerto ifbResponse classJune 18, 2022 (v1.0.0)Initial Release
Package: zermelo-api-vogk
zermelo_api_vogkA small module to create a Zermelo accesstoken and put some data from Zermelo in dataclassesV0.3.15changed vakdoclok from subjects to choosableindepartmentsV0.3.10 - V0.3.14added VakDocLoks toinitchange of vakdocloks to raw data onlybugfix filename vakdoclokstesting choosablle_etc in vakdoclokswrong copy of codeV0.3.9change lesgroepnaamV0.3.5 -> V0.3.8added lokalen, removed debug from zermelo_apiadded vakdocloksbugfix: added lokalen to dataclass of branchbugfix: subject in data vakdocloks is str not intV0.3.1 -> 0.3.4start adding function to get teachers and locations for all subjects in a certain timespan.V0.2.18added updatePackage to update remote package (linux)V0.2.17re-enabled loggerV0.2.16found bug when running as daemon, probably: logger.try without output to fileV0.2.15disabled debug modeV0.2.14debug on for bugfixingadded extra debug log for filter in lesgroepenedit filter to find second part of groupname in les.groupsV0.2.13New bug: loading of stamgroepen as lesgroep is broken!need to update/edit filter in lesgroepenV0.2.12removed debug for wisa and lesgroepenV0.2.11added groep.extendentName to filter in lesgroepV0.2.10trying to optimize lesgroepenadded (temp) debug to lesgroepenlog groupV0.2.9removed dependency of Groepen in Vakken (ot used)added getName to Vak (Vakken)start cleanup codeV0.2.8changed definition of Vakken and Groepen in Branchadded Vakken & Vak toinit.pyV0.2.7added response as data in getData on wrong outputrefactoring of Appointmentsadded function: get_department_updates [doesn't work atm :( ]V0.2.6removed linebreaks from logger.write()V0.2.5trying getting extra data for each appointment from userchanged "with_id" in get_data to "from_id" and reversed functionality for better readabilityadded classmethod to Appointment to get Appointment direct from idV0.2.4added getting appointmentsV0.2.3changed getting lesgroepen only as return so not part of branch anymoreremoved lastcheck from lesgroepenV0.2.2bugfix lesgroepenadded write to logger (debug)changed repr of UsersV0.2.1added datetime to each branchinit of branches is now only datestring, year will be determined internallyV0.2.0changed decorator from_zermelo_dict to functionV0.1.3added lesgroepenV0.1.2added VakkenV0.1.1added groepen / groupsFirst setup of vakkencleanup of codeV0.1.0: First Refactoring already:deleted fields.py and moved usefull functions to zermelo_apiloading of data for (zermelo)list generalized in zermelo_apiV0.0.8:Added loading of Users (Leerlingen & Medewerkers)Added backtracker to MyLoggerV0.0.7:Added Loading of BranchesV0.0.1 -> V0.0.5:Experimenting with creating of own package and major structure of project
Package: zermelo.py
Zermelo.pyA Python implementation of theZermelo API.FeaturesGet appointments from a zermelo calendar.Get data of a zermelo user.Get announcements.InstallationTo install the package run this command:pipinstallzermelo.pyUsageClientClient()params:School: String ? Name of the school.Result:Client: Zermelo.Client()Demo:fromzermeloimportClientcl=Client("scalacollege")AuthenticationClient.authenticate()Params:Code: String ? A connect code you get from https://YOURSCHOOLNAME.zportel.nl/main/#connectionsModule-connectAppResult:Token: dict()Demo:token=cl.auhtenticate("441 440 997 507")print(token["access_token"])UserClient.get_user()Params:Token: String ? Access_token you get from the Client.Authenticate() functionResult:User: dict()Demo:user=cl.get_user(token["access_token"])print(user)AppointmentsClient.get_appointments()Params:Token: String ? Access_token you get from the Client.Authenticate() function
StartUnix: int ? Unix timestamp for the first date you want to get the appointments from.
EndUnix: int ? Unix timestamp for the last date you want to get the appointments from.Result:Appointments: dict()Demo:appointments=cl.get_appointments(token["access_token"],1567468800,1568073600)print(appointments)AnnouncementsClient.get_announcements()Params:Token: String ? Access_token you get from the Client.Authenticate() functionResult:Announcements: dict()Demo:announcements=cl.get_announcements(token["access_token"])print(announcements)EnrollmentsClient.get_liveschedule()Params:Token: String ? Access_token you get from the Client.Authenticate() function
Week: String ? The ISO-week for which you want to request the schedule
Usercode: String ? The code of the student you want to request the schedule ofResult:Enrollments: dict()Demo:usercode=cl.get_user(token["access_token"])["response"]["data"][0]["code"]enrollments=cl.get_liveschedule(token["access_token"],"202150",usercode)# Requests week 50 of the year 2021print(enrollments)LicenseMIT
Package: zernike
ZernikePython code to handle complex- and real-valued Zernike polynomials. This module
was part ofenzpybut will be
further developed here instead.InstallationYou can installzernikeusingpippipinstall--userzernikeExample: plot the Zernike pyramidpython-mzernike.pyramidExample: plot the first 9 Zernike polynomialsimportnumpyasnpimportmatplotlib.pyplotaspltfromzernikeimportRZerncart=RZern(6)L,K=200,250ddx=np.linspace(-1.0,1.0,K)ddy=np.linspace(-1.0,1.0,L)xv,yv=np.meshgrid(ddx,ddy)cart.make_cart_grid(xv,yv)c=np.zeros(cart.nk)plt.figure(1)foriinrange(1,10):plt.subplot(3,3,i)c*=0.0c[i]=1.0Phi=cart.eval_grid(c,matrix=True)plt.imshow(Phi,origin='lower',extent=(-1,1,-1,1))plt.axis('off')plt.show()Example: fit Zernike polynomials in Cartesian coordinatesimportnumpyasnpimportmatplotlib.pyplotaspltfromzernikeimportRZerncart=RZern(6)L,K=200,250ddx=np.linspace(-1.0,1.0,K)ddy=np.linspace(-1.0,1.0,L)xv,yv=np.meshgrid(ddx,ddy)cart.make_cart_grid(xv,yv)c0=np.random.normal(size=cart.nk)Phi=cart.eval_grid(c0,matrix=True)c1=cart.fit_cart_grid(Phi)[0]plt.figure(1)plt.subplot(1,2,1)plt.imshow(Phi,origin='lower',extent=(-1,1,-1,1))plt.axis('off')plt.subplot(1,2,2)plt.plot(range(1,cart.nk+1),c0,marker='.')plt.plot(range(1,cart.nk+1),c1,marker='.')plt.show()Example: fit Zernike polynomials in polar coordinatesimportnumpyasnpfromzernikeimportRZern,FitZernpol=RZern(6)L,K=200,250ip=FitZern(pol,L,K)pol.make_pol_grid(ip.rho_j,ip.theta_i)c_true=np.random.normal(size=pol.nk)Phi=pol.eval_grid(c_true)c_hat=ip.fit(Phi)R=np.zeros((pol.nk,3))R[:,0]=c_trueR[:,1]=c_hatR[:,2]=np.abs(c_true-c_hat)print(R)np.linalg.norm(c_true-c_hat)/np.linalg.norm(c_true)Installation from the GitHub repositoryYou should first install the following requirements:Anaconda for Python 3. This includes
Python as well as some necessary scientific libraries.Git. This is necessary for the
automatic version numbering of this package. Also, make sure you chooseGit from the command line and also 3rd-party softwareinAdjusting
your PATH environment.Clonethis repository using Git. From any folder in File Explorer,
right-click and hitGit Bash here. Pastegit clone https://github.com/jacopoantonello/zernikeand hit enter. Do not use
GitHub'sDownload ZIPbutton above, as the installation script will not
work in that case.Finally, double-click oninstall.bat.Testspython-mzernike.test
Package: zernpol
This simple package offers tools to handle Zernike Polynoms and the different indexing systems (as the
Noll system for instance).The package offers object and non-object oriented functions.InstallFrom pip:> pip install zernpolFrom sources:> git clone https://gricad-gitlab.univ-grenoble-alpes.fr/guieus/zernpol.git
> cd zernpol 
> python setup.py installDocumentationPlease visits:https://zernpol.readthedocs.io/en/latest/#
Package: zero
# Zero
Linear electronic circuit utility. This package provides tools to simulate responses and noise in
linear electronic circuits, SI unit parsing and formatting, datasheet grabbing, and more.This tool’s simulator is inspired by [LISO](https://wiki.projekt.uni-hannover.de/aei-geo-q/start/software/liso),
and comes bundled with its op-amp library ([including tools to search it](https://docs.ligo.org/sean-leavey/zero/cli/library.html#search-queries)).
It also ([somewhat](https://docs.ligo.org/sean-leavey/zero/liso/input.html#known-incompatibilities))
understands LISO input and output files, and can plot or re-simulate their contents.## Documentation
See the [online documentation](https://docs.ligo.org/sean-leavey/zero/).## Installation
This library requires at least Python 3.6. It will not work on earlier versions of Python 3, nor
Python 2. You may wish to usevirtualenvorcondato manage a separate environment with Python
3.This library contains asetup.pyfile which tells Python how it should be installed. Installation
can be automated usingpip. Open up a terminal or command prompt (Windows) and type:`bash pip install zero `This installs the library and adds a console scriptzerowhich provides access to the package’s
command line utility.If you want to update the library to a later version after having previously installed it, run:`bash pip install zero--upgrade`## Contributing
Bug reports and feature requests are always welcome, as are code contributions. Please use the
project’s [issue tracker](https://git.ligo.org/sean-leavey/zero/issues).## Future ideasAllow arbitrary op-amp noise spectra (interpolate to the frequency vector actually used)Split op-amp families into their own library filesSome sort of system for sharing op-amp, regulator, resistor, etc. library data across the webA standardised export file format (XML?)Other types of noise, e.g. resistor excess noiseOp-amp noise optimisation: here’s my circuit, this is the frequency band I care about, now
what’s the best op-amp to use?Grouped components that are represented as a single component in the input definition:filters, e.g. whitening filtersreal passive components: capacitors with ESR, resistors with stray inductance, etc.## Credits
Sean Leavey
<sean.leavey@ligo.org>Invaluable insight into LISO’s workings provided by Gerhard Heinzel. The author is also grateful for
contributions by Sebastian Steinlechner.
Package: zerobin
0bin: a client side encrypted pastebin0bin is a pastebin that encrypts the user content in the browsder and can run without a database.Try it:0bin.netReport a bug0bin allows anybody to host a pastebin while welcoming any type of content to
be pasted in it. The idea is that one can (probably…) not be legally entitled
tomoderate the pastebin contentas they have no way to decrypt it.It’s an Python implementation of thezerobin project, created by sebsauvage, under theWTFPL licence.To run zerobin, download zerobin.pyz from the latestreleasethen:python zerobin.pyz0bin requires Python 3.7 or higher.You may need to typepy -3.7 zerobin.pyzon Windows, orpython3.7 zerobin.pyzon Mac/Linux, depending on your configuration.If you are familiar with the Python ecosystem, you can alsopython -m pip install zerobin --userand runpython -m zerobinfor the same effect.How it worksWhen creating the paste:the browser generates a random key;the pasted content is encrypted with this key using AES256;the encrypted pasted content is sent to the server;the browser receives the paste URL and adds the key in the URL hash (#).When reading the paste:the browser makes the GET request to the paste URL;because the key is in the hash, the key is not part of the request;browser gets the encrypted content end decrypts it using the key;the pasted decrypted content is displayed and sourcecode is highlighted.Key points:because the key is in the hash, the key is never sent to the server;therefore it won’t appear in the server logs;all operations, including code coloration, happen on the client-side;the server is no more than a fancy recipient for the encrypted data.Other featuresautomatic code coloration (no need to specify the language);pastebin expiration: 1 day, 1 month or never;burn after reading: the paste is destroyed after the first reading;clone paste: you can’t edit a paste, but you can duplicate any of them;code upload: if a file is too big, you can upload it instead of using copy/paste;copy paste to clipboard in a click;own previous pastes history;reader mode;Known issues0bin uses several HTML5/CSS3 features that are not widely supported. In that case we handle the degradation as gracefully as we can.The pasted content size limit check is not accurate. It’s just a safety net, so we think it’s ok.ContributingWe cannot accept contributions for the moment, and will ignore PR.