Saravanan666/pypi-org huggingface dataset:
Package: planetriangles
planetrianglesMostly you will use:err_msg, a, b, c, A, B, C = complete_the_triangle(a, b, c, A, B, C)This is the main routine in the plane_triangles.py module.  Its input parameters default to None.It solves (if possible) for the missing sides and/or angles in the parameter list.If two solutions are possible, it will indicate this by a return value inerr_msgthat starts with “Other”. The
first answer should be used, then a request made for the return of the second by repeating the original call with
thessa_flagset to'other', i.e.err_msg, a, b, c, A, B, C = complete_the_triangle(a, b, c, A, B, C, ssa_flag=’other’)Installationpip install planetrianglesThen, to get started, from a python REPL you can run the exerciser with …>>> from planetriangles.exerciser import run_ui
>>> run_ui()Load the user functions with …>>> from planetriangles.plane_triangles import *All of the exported functions have help text included.
So you can get help
with the usualhelp(complete_the_triangle)method. There are a number of formatting routines for converting angles
to various forms (radians, degrees, degrees and minutes, degrees minutes seconds) with a specified precision.The module (plane_triangles_tests.py) contains a set of tests. It usesassertstatements to detect
errors. Importing the module will run the tests. All is well when noassertthrows an exception.There is an interactive test/excercise program that can be invoked by importing and executingrun_ui()from the
moduleexcerciser.py.  To get it started,
do this …>>> from planetriangles.exerciser import run_ui
>>> run_ui()It starts with a prompt that allow one to set the desired format
for the display of angles (radians, degrees, degrees and minutes, degrees and minutes and seconds).The next two prompts allow the precision (number of digits to right of decimal point) for angles and lengths to be
specified.A loop is then entered that prompts for the sides and angles to be used. Just press enter to indicate that a value will
not be provided (i.e., is to be calculated).If all six parameters are left empty, the loop terminates.Example>>> from planetriangles.exerciser import run_ui()
>>> run_ui()
.
Session started...
.
Angle format to use [r, d, dm, dms]: d
Angle precision (digits to right of decimal point) to use: 4
Length precision (digits to right of decimal point) to use: 4
.
Side a: 1
Side b: 1
Side c:
Angle A (degrees):
Angle B (degrees):
Angle C (degrees): 90
a: 1.0000 b: 1.0000 c: 1.4142   A: 45.0000d B: 45.0000d C: 90.0000d
Package: planets
planetsLibrary to provide planetary constantsFree software: MIT licenseDocumentation:https://planets.readthedocs.io.FeaturesTODOCreditsPlanetary DatabaseModified by Paul Hayne from the “planets.py” library by Raymond T. PierrehumbertLast modified: June, 2017Sources:http://nssdc.gsfc.nasa.gov/planetary/factsheet/Lang, K. (2012). Astrophysical data: planets and stars. Springer Science & Business Media.Python packagingThis package was created withCookiecutterand the forkedmichaelaye/cookiecutter-pypackage-condaproject template.History0.1.0 (2019-05-22)First release on PyPI.0.2.0 (2019-06-26)Change source of constants toastropy.constants.
Package: planetscope
# planet_utilitiesDocumentation:https://www.nsstc.uah.edu/users/ankur.kumar/seaice/html/index.htmlTheplanetscopepackage is a tool specifically designed to read and plot data from the PlanetScope satellite imaging system. The PlanetScope satellite imaging system is a collection of small, remote sensing satellites that capture high-resolution images of the Earth’s surface. These images are used for a variety of applications, including mapping, land use analysis, and disaster response.Theplanetscopepackage allows users to easily access and visualize this data by providing functions for reading and parsing the raw data files, as well as functions for generating plots and maps from the data. The package also includes tools for processing the data, such as image cropping, resampling, and band math.In addition to its visualization capabilities, theplanetscopepackage also includes functions for generating training data for machine learning algorithms. These functions allow users to extract specific features from the satellite images, such as land cover types or building footprints, and format them in a way that is suitable for use as training data. This can be particularly useful for tasks such as land use classification or object detection.PlanetScope is a satellite imagery provider that offers high-resolution imagery of the Earth’s surface for various industries, including agriculture, construction, and environmental monitoring. A Python package that has been developed to read and plot PlanetScope data might include the following features:Reading in and parsing PlanetScope data: This package would likely include functions for reading in and parsing PlanetScope data from various file formats, such as GeoTIFF.Visualizing PlanetScope data: The package might include functions for visualizing the satellite imagery, such as plotting the images on a map or creating an animation of a time series of images.Extracting features from PlanetScope data: The package might include functions for extracting features from the satellite imagery, such as calculating the mean or standard deviation of pixel values within a region of interest.Generating training data for machine learning algorithms: The package might include functions for generating training data for machine learning algorithms by extracting features from the satellite imagery and labeling them according to a specific task, such as land cover classification.Overall, a Python package for reading and plotting PlanetScope data could be useful for a wide range of applications, including agriculture, construction, and environmental monitoring. It could also be used to train machine learning algorithms for tasks such as land cover classification.
Package: planet_stack_finder
# Planet Labs Stack Finder #Find locations where there are deep stacks of imagery by clustering the location of geojson polygons.Input is a list of geojson dictionaries.Each dictionary in the list must have keys [‘geometry’][‘coordinates’] or
[‘coordinates’]## Generic Setup ##pip install planet_stack_finder## Setup from github repo ##pip install -e .[test]## Tests ##pytest## CLI ##`find-stacks/path/to/file.metadata cat path/to/file.geojson | planet search |find-stacks`## Python ##` from stackfinder import findstacks `
Package: planetterp
PlanetTerp API Python WrapperThis is a Python wrapper around thePlanetTerp API.To install, either usethe code on GitHub, or install withpip install planetterp(you might need to runpip3 install planetterp).Example usageimportplanetterpcourse=planetterp.course(name="MATH140",reviews=True)courses=planetterp.courses(department="MATH",limit=2)prof=planetterp.professor(name="Jon Snow",reviews="true")profs=planetterp.professors(type_="ta",limit=2)grades=planetterp.grades(course="MATH140",professor="Jon Snow")print(course)print(courses)print(prof)print(profs)print(grades)
Package: planet-utils
# planet_utilitiesDocumentation:https://www.nsstc.uah.edu/users/ankur.kumar/planetutil/planet_utils/docs/_build/html/index.htmlTheplanetscopepackage is a tool specifically designed to read and plot data from the PlanetScope satellite imaging system. The PlanetScope satellite imaging system is a collection of small, remote sensing satellites that capture high-resolution images of the Earth’s surface. These images are used for a variety of applications, including mapping, land use analysis, and disaster response.Theplanetscopepackage allows users to easily access and visualize this data by providing functions for reading and parsing the raw data files, as well as functions for generating plots and maps from the data. The package also includes tools for processing the data, such as image cropping, resampling, and band math.In addition to its visualization capabilities, theplanetscopepackage also includes functions for generating training data for machine learning algorithms. These functions allow users to extract specific features from the satellite images, such as land cover types or building footprints, and format them in a way that is suitable for use as training data. This can be particularly useful for tasks such as land use classification or object detection.PlanetScope is a satellite imagery provider that offers high-resolution imagery of the Earth’s surface for various industries, including agriculture, construction, and environmental monitoring. A Python package that has been developed to read and plot PlanetScope data might include the following features:Reading in and parsing PlanetScope data: This package would likely include functions for reading in and parsing PlanetScope data from various file formats, such as GeoTIFF.Visualizing PlanetScope data: The package might include functions for visualizing the satellite imagery, such as plotting the images on a map or creating an animation of a time series of images.Extracting features from PlanetScope data: The package might include functions for extracting features from the satellite imagery, such as calculating the mean or standard deviation of pixel values within a region of interest.Generating training data for machine learning algorithms: The package might include functions for generating training data for machine learning algorithms by extracting features from the satellite imagery and labeling them according to a specific task, such as land cover classification.Overall, a Python package for reading and plotting PlanetScope data could be useful for a wide range of applications, including agriculture, construction, and environmental monitoring. It could also be used to train machine learning algorithms for tasks such as land cover classification.
Package: planfftw
planfftwplanfftw provides Julia-inspired function planners for fft and a number of fft-
based operations. The initial objective was to provide a clean and highly
optimized interface to the excellentPyFFTWpackage. However, PyFFTW is not a strict requirement and planfftw falls back on
scipy.fftpack or numpy.fft, should it not be available.Issues, requests and questions can be raised at the Githubissues-page.The documentation, albeit somewhat crude, is available onRead the Docs.RequirementsPython 3.5 or higher
numpy 1.16.1 or higherEarlier versions may very well work but are not tested.Highly recommendedPyFFTWInstallationInstall with::pip install planfftwor::easy_install planfftw
Package: planga
Planga Python Wrapper:Setup:Install Twine:pip install twinerequirements:Python>= 2.7.x.pipvirtualenv (Optional)Build and Deploy new package:runpython3 setup.py sdist bdist_wheelruntwine upload --repository-url https://test.pypi.org/legacy/ dist/* --skip-existingInstalling the new package:runpython -m pip install jwcryptorunpython -m pip install --index-url https://test.pypi.org/simple/ plangaInstalling jwcrypto manually is only necessary when uploading the planga wrapper to test.pypi.org. The installation tool will attempt to install jwcrypto from test.pypi.org as well, which fails. Having jwcrypto pre-installed allows the installation of the planga wrapper to finish successfully.Deploy to live Pypi:runtwine upload dist/* --skip-existingFor information on how to package for PiPy:https://packaging.python.org/tutorials/packaging-projects/Example usage:fromplangaimport*conf=PlangaConfiguration("foobar","kl9psH9VrLZ1hfsPY0b3-W","general","1234","Bob","my_container_div")snippet=Planga.get_planga_snippet(conf)
Package: planhat
Planhat PythonPlanhat API Python client libraryhttps://docs.planhat.com/Installationpip install planhatUsagefromplanhatimportPlanhat# See https://docs.planhat.com/#base-urlfromplanhatimportAPI_URL,API_URL_EU,API_URL_US2# https://app.planhat.com/developerplanhat_client=Planhat(API_URL,'tenant-token','api-token')companies_data=planhat_client.get_companies()
Package: planif-neige-client
# planif-neige-clientA python client for the City of Montreal’s Snow Removal API.
I created this library to load street snow clearing status into my HomeAssistant based home automation setup.Data is provided under the city’s Open Data initiaitve and requires an API key provided by the city of Montreal. For more info, and to request an API key, visithttp://donnees.ville.montreal.qc.ca/dataset/deneigementDISCLAIMER: I am in no way affiliated to the City of Montreal.Install using pip:pip3 installplanif-neige-client
Package: planingfsi
PlaningFSIPlaningFSI is a scientific Python program use to calculate the steady-state response of two-dimensional marine structures planing at constant speed on the free surface with consideration for Fluid-Structure Interaction (FSI) and rigid body motion.
It was originally written in 2012-2013 to support my Ph.D. research and has recently (2018) been updated and released as open-source.Cautionary NoteI am currently working on releasing this package as open source.
Since this is my first open-source release, the next few releases on PyPI should not be used for production.
I will release version 1.0.0 and remove this note once I feel that I have sufficiently cleaned up and documented the code.Required Python versionThe code is written in Python and was originally written in Python 2.6.5.
it has since been updated to require Python 3.6+.InstallationPlaningFSI can be installed with pip:pip install planingfsiContributingTo contribute, you should install the code in developer mode.poetry install --develop=.Getting StartedThe main command-line interface is calledplaningFSIand can be called directly, once appropriate input files have been prepared.
A collection of examples can be found in thetutorialsdirectory in the source package.
Package: plankton
# Plankton - html to pdf REST serviceUses wkhtmltopdf as backend.
Only works with python 3.5 or greater.Enspired by:https://github.com/openlabs/docker-wkhtmltopdfandhttps://github.com/incuna/django-wkhtmltopdf.## Installation
1.`pip install plankton`2. download and install wkhtmltopdfhttp://wkhtmltopdf.org/downloads.html.
3. Run server```plankton-server```If you want to run in docker container:Clone repo`git clonegit@github.com:django-stars/plankton.git``cd plankton`Build docker image`docker build-tplankton .`Run container`docker run-p9003:8080  plankton`.You can specify wkhtmltopdf command and port:`plankton-server--wkhtmltopdf_command'/usr/local/bin/wkhtmltopdf'--port9000`## UsagePOST`http://127.0.0.1:9003/html-to-pdf/`DATA`{"page":"http://google.com.ua"}`You can provide wkhtmltopdf options:DATA`{"page":"http://google.com.ua","options":{"javascript-delay":2000, "cookie":[["key1","val1"],["key2","val2"]]}}`## TODO
Project currently under developing and there are lot of things to do:debug modeHTTP OPTIONSloggingsecurity…
Package: planned
plannedplanned is job monitoring library which designed to observe user-defined triggersInstallationTo install Puppets, simply use pip:pipinstallplannedFor DevelopersIf you use VSCode, run this command at project root for applying formatter and linter on save.cp.vscode/template/settings.json.vscode/settings.json計画通り (planned in Japanese)「計画通り」とは、日本のサスペンス漫画『DEATH NOTE』の主人公である夜神月の名言で、事が上手く運んだ様を表す。--dic.pixiv.net(ピクシブ百科事典)
Package: plannerbenchmark
Local Motion Planning Benchmark SuiteThis repository is meant to allow quick comparison between different
local motion planning algorithms. Running and postprocessing is
available and we aim to offer a nice interface to implement a wrapper to
your own motion planner.ScreenshotsTrajectory planar armTrajectory point robotSimulation panda armEvaluation of seriesGetting startedThis is the guide to quickly get going with the local motion planning
benchmark suite.Pre-requisitesLinux Ubuntu LTS >= 18.04Python >3.6, < 3.10pip3gnuplot (sudo apt install gnuplot)[Optional]poetry[Optional]embotech forces
profor mpc[Optional]acados_templatefor mpcInstallationYou first have to download the repositorygit clone git@github.com:maxspahn/localPlannerBench.gitThen, you can install the package using pip as:pip3 install .Optional: Installation with poetryIf you want to usepoetry, you have
to install it first. See their webpage for instructionsdocs. Once poetry is installed, you
can install the virtual environment with the following commands. Note
that during the first installationpoetry updatetakes up to 300 secs.poetry update
poetry installThe virtual environment is entered bypoetry shellTutorialSimpleThe following is a very simple example case containing a point mass robot and a PD planner.Run an experiments:Experiments should be added in separate folder inexamples. One
very simple example can be found in this folder. Note that you need to
active your poetry shell if you have installed the package using poetry
bypoetry shellOr alternatively active your virtual python environmentThen you navigate there bycd examples/point_robotThen the experiment is run with the command line interfacerunner -c setup/exp.yaml -p setup/pdplanner.yaml --renderPostprocessing:The experiments can be postprocessed using the provide executable. Again make sure you are in the virtual environment, when
using poetry run:
(poetry shell)cd examples/point_robotThe you can run the post processor with arguments aspost_process --exp path/to/experiment -k time2Goal pathLength --plotAdvancedTo showcase the power of localPlannerBench we would also like to show you a more complex example, containing the 7-DoF frankaemika panda robot arm and a custom opensourceacadosbased MPC planner.Again make sure you are in your virtual python environment.poetry shellInstallacados_templateinside of the virtual environment if you haven't already.Then you navigate tocd examples/panda_armThen the experiment is run with the command line interfacerunner -c setup/exp.yaml -p setup/acados_mpc.yaml --renderThe you can run the post processor with arguments aspost_process --exp results --latest -k time2Goal pathLength --plot
Package: planning-graph
planning-graphPlanning Graph for AI Planning in PythonAboutThis library implements Planning Graph and its Planner that can be used to solve
STRIPS-like AI Planning Problems using PDDL.When passed the domain and problem representations in PDDL, the library returns
Solution Plan if any.DocumentationIf you are interested in understanding the Planning Graph, please read my post
athttps://towardsdatascience.com/improving-classical-ai-planning-complexity-with-planning-graph-c63d47f87018Installationpip install planning-graphor, you can clone this repositoryExamplePDDL for representing planning domain and problemThe Dock-Worker Robots Domain and Problem are provided in thedomaindirectory.
You can create your own PDDL files, or you can download from the internet.Create a Planning Graph from PDDLfromplanning_graph.planning_graphimportPlanningGraphplanning_graph=PlanningGraph('domain/dock-worker-robot-domain.pddl','domain/dock-worker-robot-problem.pddl')graph=planning_graph.create(max_num_of_levels=10)planning_graph.create() returns a Graph object if the goal state is achieved, or
the maximum number of levels have been reached.Create visualizationIf you want to visualize the generated graph you can set visualize=True, by default
it is set to False.fromplanning_graph.planning_graphimportPlanningGraphplanning_graph=PlanningGraph('domain/dock-worker-robot-domain.pddl','domain/dock-worker-robot-problem.pddl',visualize=True)graph=planning_graph.create(max_num_of_levels=10)graph.visualize_png("generated_graph.png")the result looks like the following:Find a Solution PlanTo find a solution plan you simply have to create a Planner and pass the arguments
it requires.fromplanning_graph.planning_graphimportPlanningGraphfromplanning_graph.planning_graph_plannerimportGraphPlannerplanning_graph=PlanningGraph('domain/dock-worker-robot-domain.pddl','domain/dock-worker-robot-problem.pddl')graph=planning_graph.create(max_num_of_levels=10)goal=planning_graph.goalgraph_planner=GraphPlanner()layered_plan=graph_planner.plan(graph,goal)it returns a layered plan if the solution exists, otherwise, it returns None.pddlpypddlpy included in this repo is the work of Hernán M. Foffani, it is copied fromhere.It is copied because it won't work when installed as a package due to wrong version of
antlr4 package. There are no changes made to it.
Package: planning-poker
The idea for the Planning Poker app came to life during the 2020 Covid pandemic with the aim to provide agile teams with
an easy way to perform their planning poker sessions from the safety of their homes. It was developed with flexibility
and extensibility in mind. Powered by a Django backend and a frontend written in Vue.js.Features🔍 This app comes with aneasy-to-use interfaceand provides all the necessary data for estimating the scope of
your stories on a single page.🗳️ The users are separated intovotersandmoderatorswho see and do different things during a session.
Seerolesfor more information.👥 See who participates in your session via alive updated list of participants.🌙 Natively supporteddark mode.ScreenshotsYou can see all the necessary information on a single pageLive updated list of participantsNatively supported dark modeQuickstartBasic understanding of Python and Django is not required but definitely recommended before you start installing this
application.Do you have Django installed? Follow these stepshereif
you haven’t.Following these steps will give you a site which you can use to test the Planning Poker App.Have an existing project where you want to include the Planning Poker app or create a new one.$ django-admin startproject planning_poker_siteInstall the app via pip.$ pip install planning-pokerConfigure your settings. They are located inplanning_poker_site/settings.pyif you chose to setup a new
project. You’ll find the minimal settings required for the Planning Poker app below. Seeconfigurationfor more ways to
customize the application to fit your needs....INSTALLED_APPS=[...'django.contrib.humanize','channels','planning_poker.apps.ChannelsPresenceConfig','planning_poker']ASGI_APPLICATION='planning_poker_site.routing.application'# This is not the optimal channel layer and should not be used for production.# See https://channels.readthedocs.io/en/stable/topics/channel_layers.html for an alternative.CHANNEL_LAYERS={'default':{'BACKEND':'channels.layers.InMemoryChannelLayer'}}LOGIN_URL='admin:login'LOGOUT_URL='admin:logout'Create arouting.pywith the following content.fromchannels.routingimportProtocolTypeRouter,URLRouterfromchannels.authimportAuthMiddlewareStackimportplanning_poker.routingapplication=ProtocolTypeRouter({'websocket':AuthMiddlewareStack(URLRouter(planning_poker.routing.websocket_urlpatterns)),})Includeplanning_poker’s URLs in your urls which can be found inplanning-poker-site/urls.pyin the
fresh project.fromdjango.contribimportadminfromdjango.urlsimportinclude,pathfromdjango.views.generic.baseimportRedirectViewurlpatterns=[path('admin/',admin.site.urls),# The first entry isn't needed but nice to have if the sole purpose of this project is serving the Planning Poker app.path('',RedirectView.as_view(pattern_name='planning_poker:index'),name='redirect_to_poker_index'),path('poker/',include('planning_poker.urls')),]Run the migrations.$ python manage.py migrateYou can now start your server.$ python manage.py runserver 0.0.0.0:8000See theuser documentationfor more
information on how to use the Planning Poker app.