Saravanan666/pypi-org huggingface dataset:
Package: pypeermap
pypeermappypeermap is a simple python tool for obtaining all the IP addresses on your local network.InstallationUse the package managerpipto install pypeermap.pipinstallpypeermapUsageimportpypeermap# returns your IPip=pypeermap.get_my_ip()# set scan rangescan_range=pypeermap.perform_scan(ip,'0/24')# returns list of client names and IP'spypeermap.get_ip_list(scan_range)ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: pypeeve
pypeevePyPeeve is a python library for python pet peeves! As a developer, you know how time-consuming and tedious it can be to write the same boilerplate code over and over again. The aim of this library is to provide a tool that helps developers to reduce their unnecessary effort in writing boilerplate codes repeatedly in every project, allowing you to focus on what really matters - solving problems and building new features.InstallationTo install the latest version, run-pip install pypeeveWhat PyPeeve OffersThere are the list of things pypeeve offers so far:LoggerLoggerPypeeve provides a set of pre-configured loggers. The simplest and
quickest way to use pypeeve logger and logger decorators is to import
a pre-configured logger that suit your need.frompypeeve.loggerimportlogger@logger.default@logger.perfdefdo_something():logger.info("Info logs")logger.error("Error logs")Output-[2023-03-27 02:28:47,680] - [DEBUG] - Entering do_something()
[2023-03-27 02:28:47,681] - [INFO] - Info logs
[2023-03-27 02:28:47,681] - [ERROR] - Error logs
[2023-03-27 02:28:47,682] - [DEBUG] - do_something() starting time: 91411.408944
[2023-03-27 02:28:47,682] - [DEBUG] - do_something() ending time: 91411.409873
[2023-03-27 02:28:47,683] - [INFO] - Total time taken to finish do_something(): 0.000929 second(s)
[2023-03-27 02:28:47,684] - [DEBUG] - Exiting do_something()The detailed documentation about the pypeeve loggers can be found inlogger readme.LicensePypeeve is distributed underMIT License. License details of all the third party tools used in pypeeve can be found inThird Party Licenses.
Package: pypefilter
PyPEfilter$ ./pypefilter.py --help
usage: pypefilter.py [-h] -s SRC [-d DST] [--rename] [--delete] [-v | -vm]

PyPEfilter filters out non-native Portable Executable files

optional arguments:
  -h, --help         show this help message and exit
  -s SRC, --src SRC  Source directory
  -d DST, --dst DST  Destination directory
  --rename           Rename matching files with their sha256 hash
  --delete           Delete non-matching files
  -v, --verbose      Display messages
  -vm, --vmagic      Display messages and magic of non-matching filesPyPEfilter filters out non-native (DLLs, .Net, Installer, ...) Portable Executable files from--srcdirectory.If--dstdirectory is provided, it copies all the matching PE files from--srcto--dst, and renames the files in the destination directory with their sha256 hash.Specifying:--rename: it renames the matching PE files in--srcwith their sha256 hash--delete: it deletes the non-matching PE files from--srcDisclaimerThis script is based onpython-magic, a Python interface to the libmagic file type identification library.
Therefore, for example, it does not identify all types of installers.
Package: pypeform-package
Pypeform: Python Package for Typeform Response PipingPypeform is a Python package designed to make inbound Typeform responses easier to work with. Provide data as aFlask requestorJSON-based dictionary, and access the response in a Pythonic/OOP manner.Note:not all field types have been implemented, but most basic fields are supported. Feel free to contribute with a PR.InstallationInstall Pypeform from PyPi:pip install pypeformUsageThere's a few handy ways to use Pypeform, depending on how you're receiving the webhook data. Most of the time, you'll be dealing with anEventobject -- a form submission. However, you can also use theFormResponseobject directly it's JSON constructors if you don't need theevent_idetc.Flask requestsThis option is useful if you're handling Typeform data in a Flask web application. This is often the case when you're using a Google Cloud Function, for example.With a full requests object, you also have the option to verify the response is legitimate, using a pre-shared secret provided in the Typeform webhook dialog.frompypeformimportEventrequest=...# Flask request objectmy_event=Event.from_request(request=request)form_response=my_event.form_responseforanswerinform_response.answers:print(answer)forfieldinform_response.fields:print(field)forvariableinform_response.variables:print(variable)JSON DataIf you have the JSON data of the response in hand, you can still construct anEventobject:importjsonfrompypeformimportEventmy_json_data=json.loads(...)# event_json must be a dict, as provided by the Typeform webhookEvent.from_event_json(event_json=my_json_data)In future versions, we'll add the ability to verify the response using the pre-shared secret (although you'll have to extract thetypeform-signatureheader from the webhook headers yourself).
Package: pyPEG2
Python is a nice scripting language. It even gives you access to its own parser
and compiler. It also gives you access to different other parsers for special
purposes like XML and string templates.But sometimes you may want to have your own parser. This is what’s pyPEG for.
And pyPEG supports Unicode.The source code for all you can find on bitbucket:https://bitbucket.org/fdik/pypeg/To build the documentation, you’ll need YML 2. You can download YML here:Homepage:http://fdik.org/yml/Toolchain:http://fdik.org/yml2.tar.bz2You can install pyPEG 2 with:pip install pypeg2pyPEG 2 depends on lxml, seehttp://lxml.de/
Package: pypegraph
pypegraphPypegraph is a python library to create directed acyclic graphs (DAG) that represent data processing pipelines. In a pypegraph graph, each node contains a function wich output is sendend to the connected nodes and are used as input of those nodes's functions.Installationpip install pypegraphCommon usagenode1=Node(lambda:print("Node1 is executing"),name="Node1")node2=Node(lambda:print("Node2 is executing"),name="Node2")node1|=node2# connect both nodes node1 -> node2outputs=node1()# dictionary with each node outputsnode1_output=outputs[node1]# None in this case because it does not return anythingnode2_output=outputs[node2]# None alsoYou can connect one node's output to a named parameter of another node's function inputdeffoo(n):returnndefsquare(number):returnnumber*numbernode1=Node(foo,name="Node1")node2=Node(square,name="Node2")node1|=(node2,"number")# connect both nodes with a connection nameoutputs=node1(2)node2_output=outputs[node2]# should be 4ConnectionsYou can connect nodes in several waysnode1=Node(lambda:print("Node1 is executing"),name="Node1")node2=Node(lambda:print("Node2 is executing"),name="Node2")# you can don1=n1|n2# orn1|=n2# orn1.connect(n2)# nodes can be disconnected withn1.disconnect(n2)
Package: pypel
pypelis a simple tool to manage receipts. It uses XMP to store metatada
inside receipts so you can share them in a very easy way.Importantpypel >=0.3 use GExiv2, pyexiv2 is not used anymore.For more info see the documentation in thedocsdirectory or browse it
online onpypel.rtfd.org.Code:https://github.com/eriol/pypelBug reports:https://github.com/eriol/pypel/issuesLicense: BSD 3-Clause
Package: pyPelias
PyPelias - Geocoding and reverse geocoding with Pelias and PythonProject DescriptionAfter installing a planet build of Pelias PyGeo was returning endless errors, It was quicker for me to write this little python API wrapper than try and sort out what the issues where with PyGeo.This package support geocoding and reverse geo coding to you're own Pelias server using requests and the Pelias API.RequirementsA complete install of Pelias. I recommend the Docker env (https://github.com/pelias/docker).Installationinstall fromhttps://pypi.org/project/pyPelias/pip install pyPeliasUsageimportpyPeliasgisAPI=pyPelias('https://mydomain_or_IP_of_pelias')# reverse geocode - get the location from lat long, in format ['lat', 'long']loc=gisAPI.reverse(['45.533467','-122.650095'])print(loc)# geocode - takes address, city, state, country in any form, raises exception if can't parse addressgeocode=gisAPI.geocode('Alamogordo, New Mexico, United States')print(geocode)NotesWe welcome your feedback and support, raise github ticket if you want to report a bug. Need new features? Contact us on github
Package: pypelined
Service and framework for creating and running processing pipelines for data streams, events and chunks.
Pipelines ofpypelinedare composed from individual elements using thechainletlibrary.
They are built in Python configuration files, from custom objects or pre-defined plugins.importchainletfrompypelined.confimportpipelines@chainlet.funcletdefadd_time(chunk):chunk['tme']=time.time()returnchunkprocess_chain=Socket(10331)>>decode_json()>>stop_if(lambdavalue:value.get('rcode')==0)>>\add_time()>>Telegraf(address=('localhost',10332),name='chunky')pipelines.append(process_chain)Once running,pypelineddrives all its processing pipelines in an event driven fashion.
Package: pypeline-db
Pypeline DB is designed to simplify the creation and management of
datasets. It has a friendly and easy-to-master API backed by the power
ofLevelDB. This allows it to
manage datasets too large to fit in RAM without sacrificing data access
performance.Pypeline is great for:Exploring data without eating all your RAMTransforming data with maps, filters and reductionsStopping you from losing or overwriting your data (unless you
explicitly ask it to)It’s also super easy to export a dataset from Pypeline to Pandas for
further analysis.LinksDocsPyPi PackageSource
Package: pypelines-etl
Pypelines-ETLSimple library to make pipelines or ETLInstallation$pipinstallpypelines-etlUsagepypelinesallows you to build ETL pipeline. For that, you simply need
the combination of anExtractor, someTransformerorFilter, and aLoader.ExtractorMaking an extractor is fairly easy. Simply decorate a function that return
the data withExtractor:importpandasfrompypelinesimportExtractor@Extractordefread_iris_dataset(filepath:str)->pandas.Dataframe:returnpandas.read_csv(filepath)Transformer or FilterTheTransformerandFilterdecorators are equivalent.Making aTransformeror aFilteris even more easy:importpandasfrompypelinesimportFilter,Transformer@Filterdefkeep_setosa(df:pandas.DataFrame)->pandas.DataFrame:returndf[df['class']=='Iris-setosa']@Filterdefkeep_petal_length(df:pandas.DataFrame)->pandas.Series:returndf['petallength']@Transformerdefmean(series:pandas.Series)->float:returnseries.mean()Note that it is possible to combine theTransformerand theFilterto shorten the pipeline syntax. For example:new_transformer=keep_setosa|keep_petal_length|meanpipeline=read_iris_dataset('filepath.csv')|new_transformerprint(pipeline.value)# 1.464LoaderIn order to build aLoader, it suffices to decorate a function that takes at
least onedataparameter.importjsonfrompypelinesimportLoader@Loaderdefwrite_to_json(output_filepath:str,data:float)->None:withopen(output_filepath,'w')asfile:json.dump({'mean-petal-lenght':{'value':data,'units':'cm'}},file)ALoadercan be called without thedataparameter,
which loads arguments (like an URL or a path). For example, callingwrite_to_json(output.json)will not execute the function, but store theoutput_filepathargument until theLoaderexecution in a pipeline.
The standard execution of the function (with thedataargument) is however still usablewrite_to_json(output.json, data=1.464).ETL pipelineTo make and run the pipeline, simply combine theExtractorwith theTransformer, theFilterand theLoaderread_iris_dataset('filepath.csv')|keep_setosa|keep_petal_length|mean|write_to_json('output.json')
Package: pypelinez
PypelinesDescriptionPython command line tool to support CI/CD for various platforms-- images --Installationpip install pypelinezUsage$pypelinezfeaturestart<feature/feature-name>Current commands:feature startfeature add-commitfeature submitfeature finishrelease startrelease add-commitrelease submitrelease finishrelease publish-startSupportRoadmap[ ] apple version bump
[ ] android version bump
[ ] documentation
[ ] Simplify version bump processContributingAuthors and AcknowledgementsLicenseMIT
Package: pypeloton
pypelotonPeloton API ClientInstallationUse pippip install pypelotonBuild locally$ git clone https://github.com/raman325/pypeloton.git
$ pip install -I pypelotonUsageThere are synchronous (Peloton) and asynchronous (PelotonAsync) classes available with the same methods available. For the purpose of demonstration we will talk about the synchronousPelotonclass.from pypeloton import Peloton

client = Peloton("my_username_or_email", "my_password")
user_id = client.get_user_id("raman325")
print(client.get_user_achievements(user_id))
print(client.get_user_workouts(user_id))Most functions will return the full payload received, so it is up to you to figure out how to get the data you need from a given method. As of now you will have to look at the source to see what functions are available, better documentation to come later.Acknowledgements@geudrik made some helpfulAPI docs@
Package: pypely
pypelyMake your data processing easy - build pipelines in a functional manner. In general this package will not make your code faster or necessarily make you write less code. The purpose of this package is to make you think differently about data processing.You are encouraged to write your data processing step by step - each step being a function. By naming each step with great awareness and chaining them together you will receive a consise and descriptive scheme of the process. This should give you and your colleagues a nice overview on how the process is structured and makes it easy to understand.
Addtionally you can test every small step easily.InstallationpipinstallpypelyUsageUsepypelyto chain functions and structure your data processing code in a readable way.use_pypely=pipeline(open_favourite_ide,create_new_conda_environment,activate_environment,install_pypely,have_fun_building_pipelines)use_pypely()# -> 🥳If you want to learn more check out the following links.LinksDocumentationExamplesContributingWhy functional?Functional programming is a data driven approach to building software - so let's move data to the center of our thinking when building data processing pipelines. To illustrate the idea a little more two analogies will be used.RailwayThe railway analogy used by Scott Wlaschin inthis talkis a good way of looking at functional programming. Withpypelyyou can easily build a route from start to finish without caring about the stops in between. :steam_locomotive:In this analogy you should translate:railway stoptointermediate resultrailwaytotranformative functionGitgitbranching might be an even easier analogy:Our every day work is managed bygitand hopefully you don't need to care about special commit hashes etc.. "Shouldn't it be the same for intermediate results in data processing?" :thinking: - "I guess I just care about raw data and processing results".In this analogy you should translate:git committointermediate resultyou writing & commiting codetotranformative functionCites by smart people (Who use functional programming)"Design is separating into things that can be composed." - Rich HickeyWhat can I use this for?This may be the main question that should be answered. This library focuses on structuring data processing, so consider it for dataframes operations. There are two libraries that need to be mentioned:pandaspysparkBut :point_up:.. if you want to build your whole application in a functional style,pypelyprovides you with the basics for this. So get creative 🤩ContributingIf you want to contribute:Woohoo! 🥳Please check out thecontribution guide.See theissuesto find a contribution possibility or create one to tell your plan and start a discussion.
Package: pypeman
Welcome to PypemanPypeman is a minimalist but pragmatic ESB / ETL / EAI in python.Seedocumentationfor more information.Getting startedInstallationWith pippip install pypeman # or
pip install pypeman[all] # To install with all optional dependenciesBasic usageCreate a fresh project with:pypeman startproject <project_dirname>Above command will create a new directory with a “settings.py” file containing
local configs and a “project.py” file with a channel example that
you can uncomment to test pypeman. Follow the commented instructions then execute:pypeman start # You can use the --reload option for auto-reloading on changesQuick command overviewTo get command help and more details about commands:pypeman --helpTo create a fresh project (partially implemented):pypeman startproject <project_name>To start pypeman:pypeman startTo show a channel graph:pypeman graph
Package: pypemicro
Python PEMicro debug probes supportThis is simple package that provides Python interface for PEMicro debug probes precompiled libraries. The package provides most of functionality
of the PEMicro libraries and their debug probes.The package is tested only with Multilink/FX and Cyclone/FX probes on NXP ARM microcontrollers.The PEMicro company helps with this development, so big Thanks to them (www.pemicro.com).Author: Petr Gargulak (NXP 2020-2023,www.nxp.com)DependenciesThere is no dependenciesInstallationDirectly fromwww.pypi.org:$pipinstallpypemicro


HistoryofPyPEMicropackageversions=====================================v0.1.11
--------February2023-Revertedbacksomechangesin0.1.11thatmakesPyPemicrononeworkingonMacOS

v0.1.10
--------February2023-FixedissuewhenthePyPemicrocausescrashofpowershellinWindows-Reformattedwholecode-Simplifiedcheckingofreopeneddriver.

v0.1.9
--------January2022-Justfixbugwithself.libmemberincaseofnotloadedPEMicrodrivers.

v0.1.8
--------January2022-TuneappbehaviorofPyPemicroconstructor.

v0.1.7
--------August2021-Addsupportfor/BSD:FreeBSD,OpenBSD,NetBSD.Thanksto:Tomasz'CeDeROM'CEDRO<tomek@cedro.info>.

v0.1.6
--------March2021-FixedbehaviorwithexceptiononussuportedOSandsometypos.-RemovedrestcommentinPyPemicroexception.

v0.1.5
--------January2021-FixedbehaviorofresetsequentionduringSWDfaultresume.

v0.1.4
--------January2021-Fixedbehaviorof"neverending"WAITacknowledgesonSWD.Nowthepackageraisedexceptioninthiscase.

v0.1.3
--------November2020-FixedopeningthedebugprobeslibrariesunderLinuxandMacOS

v0.1.2
--------November2020-FixedlistingthedebugprobesunderLinuxandMacOS

v0.1.1
--------November2020-FixedlistofPEMicrodynamiclibraries,fordifferentOS

v0.1.0
--------October2020-Initialversion-SupportedmostofthefunctionalityofPEMicroprobes(ARMcontrollers)
Package: pypen
Express your creativity in Python through simple PyPen sketches!What is PyPen?PyPen tries to be the end-all solution to creative coding in Python. It provides very easy-to-use functions for drawing primitives to the screen and getting user input.We felt like there was always a bunch of overhead needed to get nice and simple HTML-canvas-like graphics to work in Python and that this overhead always made for a half-baked user experience.PyPen is basically doing all of the boring stuff in the background and exposes simple functions likeclear(),circle(x, y, radius),rectangle(x, y, width, height)and many more for you to use and express your creativity with.How do I Use PyPen?Checkout our setup tutorial:How do I Use PyPenTL;DR:typepip install pypenand follow instructions if any extra dependencies are needed.typepypen --init example, which will create a file named example.py in your current directory.The example.py file will look like this:frompypenimport*defstart():settings.fps=60defupdate():fill_screen("orange")rectangle(20,20,300,400,"red")typepypen exampleand a window should popup with something looking like this:edit the example.py file by checking out PyPen's documentation andexamplesInspiration from our Examples:Example 002Example 003Example 006Example 007Example 010Example 011(For Maintainers)How does PyPen work?We have an entire page dedicated to explaining the inner workings of PyPen. If you are a developer interested in helping PyPen's development, you should check it out:How does PyPenReallyWork?
Package: pypendency
PypendencyPypendency is a dependency injection library for python >=3.7.InstallationpipinstallpypendencyUsagePypendency supports:Declaration of explicit dependencies for each registered service.Lazy evaluation (dependencies are not evaluated and instantiated until they are required)Loading dependencies from different sources, such as python file, yaml file or directories.
Also, it can be done programmatically.Examples# application_bootstrap.pyfrompypendency.builderimportcontainer_builderfrompypendency.definitionimportDefinitionfrompypendency.loaders.yaml_loaderimportYamlLoaderfrompypendency.loaders.py_loaderimportPyLoader# Manuallycontainer_builder.set('random_object',object())container_builder.set_definition(Definition('another_random_object','builtins.object'))# File by fileYamlLoader(container_builder).load('/absolute/path/to/yaml/example.yaml')PyLoader(container_builder).load('/absolute/path/to/python_file/example.py')PyLoader(container_builder).load_by_module_name('python_file.example')# Specifying a directoryYamlLoader(container_builder).load_dir('/absolute/path/to/yaml/')PyLoader(container_builder).load_dir('/absolute/path/to/python_file/')# path_to_yaml/example_di.yamlexample_class_identifier:fqn:example.class.namespace.ClassNameargs:-'@another_example_class_identifier'kwargs:example_kwarg:'@random_object'# python/file/namespace/example_di.pyfrompypendency.argumentimportArgumentfrompypendency.builderimportContainerBuilderfrompypendency.definitionimportDefinitiondefload(container_builder:ContainerBuilder):container_builder.set("literal_string","example_literal_string")container_builder.set_definition(Definition("another_example_class_identifier","another.example.class.namespace.AnotherClassName",[Argument.no_kw_argument("@literal_string"),Argument("kw_arg_example","@literal_string"),]))Running testsBuild the docker image:dockerbuild.-tpypendency-devRun tests:dockerrun-v$(pwd)/.:/usr/src/apppypendency-devbash-c"pipenv run make run-tests"
Package: pyPENELOPEtools
pyPENELOPEtoolspyPENELOPEtoolsis an open-source software to facilitate the use of the
Monte Carlo code PENELOPE and its main programs such as PENEPMA.
It is a programming interface to setup, run and analyze Monte Carlo simulations.
Most of the code was adapted frompyPENELOPE, but
with the goal to facilitate the integration withpyMonteCarlo.What is PENELOPE?PENELOPE (Penetration and ENErgy LOss of Positrons and Electrons) is a
a general-purpose Monte Carlo code system for the simulation of coupled
electron-photon transport in arbitrary materials.
PENELOPE covers the energy range from 1 GeV down to, nominally, 50 eV.
The physical interaction models implemented in the code are
based on the most reliable information available at present, limited only by
the required generality of the code.
These models combine results from first-principles calculations, semi-empirical
models and evaluated data bases.
It should be borne in mind that although PENELOPE can run particles down to 50
eV, the interaction cross sections for energies below 1 keV may be affected by
sizeable uncertainties; the results for these energies should be considered as
semi-quantitative.PENELOPE incorporates a flexible geometry package called PENGEOM that permits
automatic tracking of particles in complex geometries consisting of homogeneous
bodies limited by quadratic surfaces.
The PENELOPE code system is distributed by theOECD/NEA Data Bank.PENELOPE is coded as a set ofFORTRANsubroutines, which perform the random sampling of interactions and the tracking
of particles (either electrons, positrons or photons).
In principle, the user should provide a main steering program to follow the
particle histories through the material structure and to keep score of
quantities of interest.DocumentationThedocumentationcontains the
installation instructions, tutorials and API.Release notes1.2.0Move tests to pytestAdd result class for PENCYL1.1.1Add enums for KPAR and ICOLAdd result from generated photon intensity1.0.0First releaseAuthorsPhilippe T. PinardHendrix DemersLicenseLicense under Apache Software License 2.0.Copyright (c) 2017- , Philippe Pinard