Saravanan666/pypi-org huggingface dataset:
Package: packetizer
Packetizer 📦Hello 👋, welcome to the Packetizer repository, your go-to tool for keeping your Python code neat and tidy.What Does Packetizer Do?Imagine working on a large Python project and you find yourmodule.pyfile has become a monolith with thousands of lines and dozens of classes. Enter Packetizer, your life-saver.With a single command, Packetizer takes that behemoth of a file, splits it into multiple files based on the classes, and even generates an__init__.pyso it all works like a proper Python package. 🎉🛠️ InstallationTo install Packetizer, simply run:pipinstallpacketizer🚀 Quick StartAssuming you have amodule.pyfull of classes, just run:packetizermodule.pyVoilà, you'll get a folder namedmodulewith each class in its own.pyfile and an__init__.pytying it all together as a package.📜 FeaturesAutomatically splits classes into their own filesGenerates an__init__.pyso it functions as a packageOption to remove unused importsUser-friendly and easy to use🤝 ContributingWe'd love to see your contributions and make Packetizer even better. Feel free to open an issue or make a pull request.
Package: packet-maze
Packet-MazeAn interactive training tool for budding network programming enthousiast's!Are you a packet wizard? How's your packet craft? Find out with this interactive trainer!Start off by doing a little setup (skip if you know what you're doing)SetupThere are two main dependencies - bcc and Python.BCCFind your OS and follow their installation guide - it's fantastic:https://github.com/iovisor/bcc/blob/master/INSTALL.mdOnce you have bcc setup on your system - run the following on the 'admin' or 'teacher' box.Python3If you don't want to run things as sudo - the folloing might work:sudosetcapCAP_NET_RAW+ep"$(readlink-f`whichpython3`)"Otherwise, install the package and startpacket_maze --iface <iface to listen on>sudosu-
pip3installpacket-maze
packet_maze--ifaceeth0PlayLet students know your IP address and MAC address and have them 'play' the following levels.Register! : 0 - ARP - LinkRegister by sending anARP replypacket across the link with a source hardware address ofFE:ED:ME:13:37:55to the interfaces broadcast addressBaby Steps... : 1 - IP - InternetTake the next steps in the wide new world of internet protocol by crafting an evil IP packet, with a payload containing your desired usernamemax length of 10 bytesAre you Alive? : 2 - ICMP - InternetKick off the next stage by sending, as an IPv4 payload, atype 13 ICMP packetwith anidvalue of hex 42, asequancevalue of 88 and anOriginate timestampas the IPv4 address 1.3.3.7Yeet! : 3 - UDP - TransportTraverse the transport layer by sending anUDP packetfrom and to port 55555 with a payload of[x)0.0(x]A Short Conversation. : 4 - TCP - TransportTraverse the transport layer again by setting up aTCP sessionon port 55555, with the first data packet containing a payload ofACK\x00\x01\x02\x03which is PSH'dWorld-Wide-Webz : 5 - HTTP - ApplicationFinish by leveraging a well known application level protocol -HTTP- complete this by sending aHTTP OPTIONSrequest for all resources usingHTTP/13at the destination port of 55555DockerNo - it's another layer of silly - you have to expose sys/modules and install the same kernel headers for docker to insert the module anyways - why do that? Open an Issue if you've a great reason.
Package: packetraven
PacketRavenPacketRaven is a dashboard built to track high-altitude balloon flights from their location telemetry.pipinstallpacketravenInstallationinstall Python -https://www.python.org/downloads/installpacketravenwithpip:pip install packetravenNOTEAlternatively, you may download the source code and build from source:gitclonehttps://github.com/UMDBPP/PacketRaven.gitcdpacketraven
pipinstall.UsagePacketRaven reads a configuration file to determine which connections to set up, how to parse your packets, which callsigns to filter, etc.packetraven/path/to/config.yamlThe configuration is in YAML format. Here is an example configuration:# config.yamlcallsigns:-W3EAX-9-W3EAX-11-W3EAX-12time:start:2022-03-05end:2022-03-06interval:30output:filename:ns110.geojsonlog:filename:ns110.logpackets:aprs_fi:api_key:123456.abcdefhijklmnoptext:locations:-/dev/ttyUSB0-~/packets.txtdatabase:hostname:localhostport:5432database:nearspacetable:ns110username:user1password:password1tunnel:hostname:bpp.umd.eduport:22username:user1password:password2prediction:start:location:--78.4987-40.0157time:2022-03-05 10:36:00profile:ascent_rate:6.5burst_altitude:25000sea_level_descent_rate:9output:filename:ns110_prediction.geojsonstart the graphical user interface (GUI)to start the GUI, add--guito anypacketravencommandpacketraven--gui
packetravenconfig.yaml--guiExampleslisten to a TNC sending raw APRS strings over USB port COM4# config.yamlpackets:text:locations:-COM4you can also set the location toautoto try the first open USB port# config.yamlpackets:text:locations:-autolisten to APRS.fi, watching specific callsignsyou need an API key to connect to APRS.fi; you can get one fromhttps://aprs.fi/page/api# config.yamlcallsigns:-W3EAX-8-W3EAX-14packets:aprs_fi:api_key:123456.abcdefhijklmnoplisten to a PostGIS database table# config.yamlcallsigns:-W3EAX-8-W3EAX-14packets:database:hostname:bpp.umd.eduport:5432database:nearspacetable:ns110username:user1password:password1watch text file(s) for new lines containing raw APRS strings# config.yamlpackets:text:locations:-http://bpp.umd.edu/archives/Launches/NS-95_2020-11-07/APRS/W3EAX-10/W3EAX-10_raw_NS95.txt-http://bpp.umd.edu/archives/Launches/NS-95_2020-11-07/APRS/W3EAX-11/W3EAX-11_raw_NS95.txtlisten to a TNC on COM3, watching specific callsigns, and synchronize new packets with a database table via SSH tunnel# config.yamlcallsigns:-W3EAX-8-W3EAX-14packets:text:locations:-COM3database:hostname:localhostport:5432database:nearspacetable:ns110username:user1password:password1tunnel:hostname:bpp.umd.eduport:22username:user1password:password2
Package: packetreader
Apcapfile parser implemented by Python. Only supports TCP and UDP packet.Installationpip install PacketReaderUsage1. Import module.import PacketReader2. Read from a pcap file.read_pcapreturn a list of packets.packets = PacketReader.read_pcap(pcap_file)3. You can print the information of each packet.print(packets[0])4. PacketReader supports IP/TCP/UDP. You can get the MAC address, IP address or flags of packets.print(packets[0].src_mac_address)
print(packets[0].tcp_header['SYN'])Example>>> import PacketReader
>>> pl=PacketReader.read_pcap('test.pcap')
>>> print(len(pl))
179
>>> print(pl[0])
Packet 1 Information:
[1] Epoch Time: 1448157839.796592 seconds
[2] Frame Length: 85 bytes
[3] Destination Mac Address: 28:C2:DD:1D:75:C1
[4] Source Mac Address: 88:25:93:37:60:84
[5] Destination IP Address: 192.168.1.183
[6] Source IP Address: 192.30.252.88
[7] Destination Port: 57747
[8] Source Port :443
[9] Protocol: 6
Package: packet-trace
This code pilfered fromcommonism/iptables-tracewith some reformatting and modification to form suitable topoetry.InstallationBefore using this script install thelibnetfilterpackage (if you usepoetry installthis willl be done automatically using the latestgitlab.comcode).UsageThis script addsTRACErules intonftablesand then analyses the resulting log output to present its results, consequently it must be run as a privileged user (one permitted to modify thenftables).
Package: packetvisualization
RequirementsHave a local mongo db server installed and running. The program uses this to create a local db instance.Install wireshark and tsharkInstall suricata and modifysuricata.yamlto export pcap fileDefault Locations:Windows: C:\Program Files\Suricata\suricata.yamlLinux: /etc/suricata/suricata/yaml- pcap-log:
  - enabled: yes
  - filename: log.pcapRunOnce your changes are done and need to run the package as if you were a user of it.
Follow these steps:Runpip install packetvisualizationRunpythonTypefrom packetvisualization import run
run()
Package: packg
packgCollection of utilities used in other python projects.Featurescaching: Cache objects to disk (usingjoblib) or to memoryconstclass.Const: Base class for defining constants, as alternative toenum.Enumdebugging: Connect to PyCharm debug serverdtime: Wrappers and formatters fordatetimeand other timing utilitieslog: Wrapper forloguru, utilities for stdlibloggingiotools: Index paths, compress and read files, git utilities, wrappers to load json/yamlmagic: Wrapper aroundimportlibmaths: Various small mathematical utilitiesmisc:format_exception(e)outputs the exception as it appears in the stacktrace.suppress_stdout_stderrcontext manager to suppress all output of a block of code.multiproc: Multiprocessing utilitiespackaging: Code to handle creation and running of python packagespaths: Load paths from the global environment or .env files usingpython-dotenvstats: Simple statistics utilitiesstrings: Base64, quote strings, create random strings, create hashes of objectssystem: Wrapper forsubprocess.Popentesting: Import all modules from a package and other utilitiestqdmext: Wrappertqdm_max_ncolsthat limits the width of atqdmprogressbar by defaulttypext: Type definitionsweb: Download file and resume a partial download, disable web accessInstallRequirespython>=3.7pipinstallpackgSetup environment paths# show environmentpython-mpackg.cli.show_env# orpackgshow_envTo override the defaults with your own values:Set the environment variables in your shell e.g. using .bashrcCreate a file named.envin the root of your project as follows:ENV_DATA_DIR=dataENV_RESULT_DIR=resultsENV_ANNO_DIR=annotationsENV_CODE_DIR=/home/${USER}/codeENV_CACHE_DIR=/home/${USER}/.cacheDev installClone repository and cd into, then:pipinstall-e.
pipinstallpytestpytest-covpylintpytest-lazy-fixture

python-mpytest--cov

pylintpackg
pylinttests
Package: packge-name
image_processingDescription.
The package image_processing is used to:
Processing:
- Histgram matching
- Structural similar
- Reslize image
Utils:
- Read image
- Save image
- Plot image
- Plot result
- Plot histogramInstallationUse the package managerpipto install image_processingpipinstallimage_processingAuthorPeterLicenseMIT
Package: packing2porenet
packing2porenetPython package to compute pore network based on given particle packing.OverviewComputes pores and throats and their properties based on given packing.spherical pores from spherical packingFirstly, the weighted (also denoted as regular) Voronoi tesselation is done based on the input spherical packing. Weights are spheres' radii.From the weighted Voronoi tesselation, Delaunay tetrahedralization is determined, resulting in the set of tetrahedrons and their connectivity.Pores are assigned for each Delaunay tetrahedron.
Size and position of the pore is assigned as an inscribed spheres between the four "vertex" spheres.Throats between pores are assigned radius equal to circle in face plane and inscribed between three "vertex" spheres.It is possible to merge overlapping pores.
Then the new pore is such that:volume is equal to the volume of spheres unionposition is weighted average of positions, with weights being input volumes
Throats related to merged pores has radius such that the area of new throat is equal to the area of both merged throats.UsageExamplefrompacking2porenetimportSphere,Voronoi,PoreNetwork,export,ymport# testing sphere packspheres=(Sphere((0.00,0.00,0.00),1.00),Sphere((2.10,0.10,0.05),1.20),Sphere((4.05,0.20,0.10),1.10),Sphere((1.15,2.15,0.15),1.15),Sphere((3.05,2.05,0.05),1.05),Sphere((2.10,4.20,0.10),1.25),Sphere((1.05,1.05,2.10),1.00),Sphere((3.15,1.10,2.20),1.10),Sphere((2.05,3.10,2.05),1.20),Sphere((2.10,2.15,4.10),1.15),)# pore networkexport.spheres2vtk(spheres,"vtk-packing")voro=Voronoi(spheres)export.network2vtk(voro,"vtk-voro")network=PoreNetwork().fromVoronoi(voro)export.spheres2vtk([pore.asSphere()forporeinnetwork.cells],"vtk-pores")export.network2vtk(network,"vtk-throats")network.mergeIntersectingPores()export.spheres2vtk([pore.asSphere()forporeinnetwork.cells],"vtk-pores-merged")export.network2vtk(network,"vtk-throats-merged")CompatibilityTested onUbuntu18.04 LTS andPython3.6InstallationUsingpippython3 -m pip install packing2porenetUsingmake(callspython3 -m pip install ., i.e. option 3, internally):make installUsingpiplocallypython3 -m pip install .ContributionMerge RequestsAre welcomeBug reportingIn case of any question or problem, please leave an issue at theGitLab page of the project.ContributorsJan StránskýLicenseThis project is licensed under theMIT License- see thelicense filefor details.TODOdocumentationtestsperiodicityother shapesother properties and functionality
Package: packingslip
# Packing SlipCommand line tools for quickly comparing files and directories.Ever need to know if a set of files was transfered correctly but are unable touse rsync?  Maybe checksumming both sides will take too long, maybe thefilesystem was remote or removable.  Use packingslip!Packingslip allows you to create _a packing slip_ just as in the world ofshipping with which you can verify that the contents are all present andintact.  As a secondary benefit this allows you to verify integrity withoutnecessarily checksumming both sides -- since the checksums were recordedduring the packing slip creation.
Package: packinit
Main Documentationpackinitis a Python based startup routine forPackmakerbased modded Minecraft servers. It can be run on any Linux system and in any container at present. It can be configured via environment variables, flags, and soon config files. (ini,yamlandtomlformats are being considered)It works by usingPackmakerto download all mods based on aPackmakeryaml and lock file. It will download the latest mods, and sync the updated configuration and mods into the server directory in a stateful way that preserves runtime data, like the world.LikePackmaker,packinitcan be given multiple pack files, which it will merge from first to last provided. This allows pack developers to release a server with pack related mods, and for server administrators to add their own maintenance packs, with mods for backup; sleep voting; and maps for example.Main Index
Package: packit-deploy
Packit DeployThis is the command line tool for deploying Packit.Install from PyPipip install packit-deployUsageSo far the only commands arestart,stopandstatus. Admin commands for managing users
and permissions will be added in due course.$ packit --help
Usage:
  packit start <path> [--extra=PATH] [--option=OPTION]... [--pull]
  packit status <path>
  packit stop <path> [--volumes] [--network] [--kill] [--force]
    [--extra=PATH] [--option=OPTION]...

Options:
  --extra=PATH     Path, relative to <path>, of yml file of additional
                   configuration
  --option=OPTION  Additional configuration options, in the form key=value
                   Use dots in key for hierarchical structure, e.g., a.b=value
                   This argument may be repeated to provide multiple arguments
  --pull           Pull images before starting
  --volumes        Remove volumes (WARNING: irreversible data loss)
  --network        Remove network
  --kill           Kill the containers (faster, but possible db corruption)Here<path>is the path to a directory that contains a configuration filepackit.yml.Dev requirementsPython3(>= 3.7)HatchTest and linthatch run testhatch run lint:fmtTo get coverage reported locally in the console, usehatch run cov.
On CI, usehatch run cov-cito generate an xml report.Buildhatch buildInstall from local sourceshatch buildpip install dist/packit_deploy-{version}.tar.gzPublish to PyPiEnsure you have built a new version of the package:hatch cleanhatch buildThen publish to the test server:hatch publish -r testYou will be prompted to enter yourtest.pypi.orgusername and password.
To test the installation, first run Python in a container:docker run --rm -it --entrypoint bash pythonThen:pip install --index-url https://test.pypi.org/simple packit-deploy --extra-index-url https://pypi.org/simpleNow you should be able to runpackitfrom the command line and see the usage instructions.If it is working, you can publish to the real PyPi:hatch publish
Package: packitos
PackitPackit is a CLI tool that helps developers auto-package upstream projects
into Fedora operating system.You can use packit to continuously build your upstream project in Fedora.With packit you can create SRPMs, open pull requests in dist-git, submit koji builds and even create bodhi updates, effectively replacing the whole Fedora packaging workflow.To start using PackitSee ourdocumentationTo start developing PackitTheContributing Guidelineshosts all information you need to know to contribute to code and documentation, run tests and additional configuration.Workflows covered by packitThis list contains workflows covered by packit tool and links to the documentation.Update Fedora dist-git with an upstream release.Build content of a Fedora dist-git branch in koji.Create a bodhi update.Create a SRPM from the current content in the upstream repository.Sync content of the Fedora dist-git repo into the upstream repository.RequirementsPackit is written in Python 3 and is supports version 3.9 or later.InstallationFor complete information on how to start using packit, pleaseclick here.User configuration fileUser configuration file for packit is describedhere.Who is interestedFor the up to date list of projects which are using packit,click here.Logo designCreated byMarián Mrva-@surfer19
Package: packly
Packly: making Python packaging easierPackly is a project designed to help make creating Python packages as easy as possible.You can add a function at the press of a button, and instantly be coding.Check out Packly - you'll never want to turn back!InstallationYou can install Packly using PyPI:python3-mpipinstallpacklyThen simply run thepacklycommand from your terminal:packlyYou may need to use thepython3 -mcommand:python3-mpacklyHappy packaging!
Package: packmaker
PACKMAKERPackmaker is a command line tool used to build Modded Minecraft modpacks on
Linux systems. It can take a yaml-based description of a pack and generate
a package suitable for use in the following formats:Curseforge- A curseforge package suitable for uploading directly to the
curseforge.com webiste, or importing into a curseforge compatible minecraft
launcher like PolyMC or the Curseforge Client.Routhio- A package format used by the minecraft.routh.io community and the
routh.io minecraft launcher.Local client- A local minecraft client installation, suitable for standalone
games.  Packmaker can even launch your modded minecraft installation in
offline mode itself. Great for testing your modpack during development.Server- A minecraft server installation, suitable for use by clients to
connect with and play together.For more information, see the official documentation site:https://packmaker.readthedocs.io
Package: packman
packmancreates packages.You can write apackages filecontaining your packages’
configuration and packman will retrieve the resources and create the
packages accordingly.The project was initally invented to create Cloudify
(http://getcloudify.org/) packages and is now progressing towards being
a simple open-source solution to creating different types of packages.Quick StartQuick
StartDocumentationpackman documentationInstallationseepackman
requirementsbefore installing packmanpipinstallpackman# or, for dev:pipinstallhttps://github.com/cloudify-cosmo/cloudify-packager/archive/master.tar.gzUsage ExamplesseePackages
Configurationto configure yourpackages file# `pkm get` retrieves package sourcespkmget--packagesmy_package--packages_file/my_packages_file.yaml# `pkm pack` packages sources, scripts and configs.pkmpack-cmy_package,my_other_package# `pkm make` ... does both one after the otherpkmmake-xexcluded_package,excluded_package2Additional Informationpackman’s cliAlternative
ImplementationsTemplate
Handlingpackman API
Package: packmap
PackMap is a simple utility which finds all dependent packages for a given Python package. It does this by installing the package and all of its dependencies into a clean temporary virtual environment and probing installed components for their actual requirements.Project:https://github.com/jmvrbanac/PackMapInstallation:PackMap is available on PyPI and can be installed with pip:pip install packmapUsage:Checking the dependencies of a package called lplight on PyPI:packmap lplight –pdf-resultsChecking the dependencies of a package on your hard drive:packmap lplight –install-type path –install-path /path/to/package –pdf-resultsResults:PackMap output’s two different type of results; JSON and PDF.JSON results: Gives you the ability to parse through the results for yourself to find changes in version numbers or requirement specs.PDF results: Produces an graph for easier viewing and consumption.NoteThe PDF results functionality requires the graphviz system package to be installed.
Package: packme
packmeoverviewpackmeis a python3 application for generating and runningpackertemplates.It works by generatingmanifest.jsonfiles out ofmanifest.ymlfiles which contain the packer settings for the image to build. Themanifest.ymlfiles will be searched in a directory which contains as subdirectories the images to be built usingpacker. That directory has to be defined from the CLI (-t/--templates-diroption) and has the following structure:my_templates_directory/image1/manifest.yml...imageN/manifest.ymlEach manifest.yml has the following structure:---
parameters:param1:value1...paramN:valueN

packer:description:packerdescriptionstringvariables:packervariablesdictbuilders:packerbuilderslistprovisioners:packerprovisionerslistpost-processors:packerpostprocessorslistThe packer section is strictly the YAML representation of a packer json file with the standards description, variables, builders, provisioners and post-processors packer fields. Those fields can contain Jinja2 templates which can be of two flavors:parametersorenvironment.parameterswill be defined in theparameterssection of the YAML file whileenvironmentwill be either environment variables or variables passed through thepackmeCLI.In order to runpackme, an input configuration file has to be provided. This file is a YAML file which declares the list of the images for whichmanifest.jsonfile will be built and run after with packer. It has the following structure:---
templates:image1:packages:[package1,...,packageN]...imageN:extends:image1wherepackagesdefines non standard packages that will added as extra provisioners when generating themanifest.jsonfile for the corresponding image.An image can extend another one by starting its building from another image. This is the aim ofextendskeyword which allows to declare that dependency.Documentationpackme documentationPrerequesitespackerQEMUInstallationpipinstallpackme
Package: packmodule
packmoduleA code packer for Python modules. Designed for use with AWS CloudFormation, which allows
embedding Python code up to 4096 bytes in size directly into a template.UsageCallpackmodule.packwith a string of your module's source code. The function returns
your code packed with the best performing of zlib, bz2, lzma, and the identity function.
The behavior of your code should not change other than some extra modules being imported.