Saravanan666/pypi-org huggingface dataset:
Package: panopta-api
Panopta API Python Package==========================The Panopta API (previously `panopta_rest_api`) provides full access to all configuration, status and outagemanagement functionality of the Panopta monitoring service, including theability to create and modify monitoring checks that are being performed, managenotification configuration, respond to active outages and to pull availabilitystatistics for monitored servers. This package makes it simple to interact withthe Panopta API.# API DocumentationFull documentation for the API is available at[https://api2.panopta.com/v2/api-docs/](https://api2.panopta.com/v2/api-docs/).By entering your API token you can view full details on all of the API methodsand issue API requests from the documentation page.# Installation```bashpip install panopta_api```# UsageThe library provides a wrapper around the Panopta API, making it easy to issueGET, POST, PUT and DELETE operations to the API. The `Client` is an adapterbuilt on top of [Requests](http://python-requests.org), so anything you can dowith a `requests.Session`, you can with `panopta_api.Client`.## Instantiate the Panopta API client```pythonfrom panopta_api import Clientclient = Client('your-api-key',host='http://api2.panopta.com',version='2',log_level=Client.LOG_INFO,log_path='logs/')```## Generate API urls```pythonresource = 'server'id = '123'collection = 'network_service'server_network_services = client.url(resource, id, collection)```## GET```pythonfive_contacts = client.get(client.url('contact'), params={'limit': 5});servers_with_a_certain_fully_qualified_domain_name = client.get(client.url('server'),params={'fqdn': 'panopta.com'})server_forty_two = client.get(client.url('server', '42'))```## POST```pythonnew_notification_schedule = client.post(client.url('notification_schedule'),json={'name': 'New Notification Schedule','targets': [server_forty_two['url']]})```## PUT```pythonupdated_server_group = client.put(client.url('server_group'),json={'name': 'Updated Server Group','notification_schedule': new_notification_schedule['url']})```## DELETE```pythonclient.delete(client.url('contact', '1'))```
Package: panopta_rest_api
The Panopta REST API provides full access to all configuration, status and outage management
functionality of the Panopta monitoring service, including the ability to create and modify
monitoring checks that are being performed, manage notification configuration, respond
to active outages and to pull availability statistics for monitored servers.InstallationTo install, just do a pip install of the package:pip install panopta_rest_apiThe library depends on the httplib2 module, which will also be installed if it’s not already
available.API DocumentationFull documentation for the API is available athttps://api2.panopta.com/v2/api-docs/.  By
entering your API token you can view full details on all of the API methods and issue API
requests from the documentation page.UsageThe library provides a wrapper around the Panopta REST API, making it easy to issue
GET, POST, PUT and DELETE operations to the API.  A sample use of the library is below.import api_client
import json

api_url = 'http://api2.panopta.com'
api_token = 'testing'
version = '2'

if __name__ == '__main__':
  #-- initialize the client
  client = api_client.api_client(api_url,
                                 api_token,
                                 version=version,
                                 log_level=api_client.LOG_DEBUG,
                                 log_path='./')

  #-- get a server
  query_params = { 'fqdn': 'panopta.com', 'limit': 10, 'offset': 0 }
  results = client.get('/server', query_params=query_params)
  print json.dumps(results, indent=2)

  #-- create a contact
  data = { 'name': 'john', 'timezone': '%s/v%s/timezone/America/Chicago' % (api_url, version) }
  results = client.post('/contact', request_data=data)
  print json.dumps(results, indent=2)
Package: panoptes
PANOPTESPanoptes is an automatic security group analyzer focused on reducing the amount of toiling. Mainly focused on AWS, built to be extensible in the future and support the big cloud providers out there.PrerequisitesFor lazy usersThere is a Docker imagetioxy/panopteswhich uses the Dockerfile located in the root of the repositoryPythonPython >= 3.6pipFor AWS usageAWS CLIinstalled and configured with your IAM credentials (if you want more customization useNamed Profiles)InstallationGet the latest version of the package from your terminal withpip:pipinstallpanoptes--upgradeGetting StartedIf you want to see the available options:panoptesctlawsanalyze--helpGenerate an AWS analysis with human readable output:panoptesctlawsanalyze--region<YOUR_REGION_CODE>Generate an AWS analysis with an YML output and a Named Profile from AWS CLI:panoptesctlawsanalyze--region<YOUR_REGION_CODE>--profile<YOUR_PROFILE>--outputymlCheck outAWS Regionsto see available region codesWhitelistingManuallyIf you wish to whitelist IPs, not letting the analysis mark them asUnsafe, you can define a sample file with the desired IPs and CIDRs, like the following one:your_whitelist.txt111.111.111.111/32
123.123.123.123/32And then run the analysis with the parameter--whitelist:panoptesctl aws analyze --region <YOUR_REGION_CODE> --output yml --whitelist /PATH/TO/your_whitelist.txtAutomaticallyPanoptes generates automatically a list of IPs which it does not consider harmful from the desired cloud provider.AWS autogeneratedVPC rangesSubnet rangesPrivate IPs from EC2 VPC InstancesPublic IPs from EC2 VPC InstancesElastic IPsLimitationsThe Automatic AWS Whitelist feature can't whitelistpublicandprivateIP's fromEC2 Classic, so make sure that those instances have anElastic IPattached and their security groups are pointing to the newElastic IPattached instead of the default EC2 Classic ones.
Package: panoptes-client
Panoptes ClientThis package is the Python SDK forPanoptes, the platform behind theZooniverse. This module is intended to allow
programmatic management of projects, providing high level access to the API for
common project management tasks.Full documentation is available at Read the
Docs.InstallationInstall latest stable release:$ pip install panoptes-clientOr for development or testing, you can install the development version directly
from GitHub:$ pip install -U git+https://github.com/zooniverse/panoptes-python-client.gitUpgrade an existing installation:$ pip install -U panoptes-clientThe Panoptes Client is supported on all versions of Python 2 and 3, from Python
2.7 onwards.Usage ExamplesCreate a project:frompanoptes_clientimportPanoptes,ProjectPanoptes.connect(username='example',password='example')new_project=Project()new_project.display_name='My new project'new_project.description='A great new project!'new_project.primary_language='en'new_project.private=Truenew_project.save()See the documentation foradditional
examples.ContributingWe welcome bug reports and code contributions. Please seeCONTRIBUTING.mdfor information about how you can get involved.Running the TestsYou can run the tests with Docker. This will run them under Python 3 and Python
2:docker-compose build tests && docker-compose run tests
docker-compose build tests2 && docker-compose run tests2Or you can run them directly in Python with:python-munittestdiscover
Package: panoptes-data
PANOPTES Data toolsTools for searching and downloading PANOPTES data.InstallInstall from pip:pipinstallpanoptes-dataExamplesSee example Jupyter Notebooks in thenotebooksfolder.Finding observations>>>frompanoptes.data.searchimportsearch_observations>>>frompanoptes.data.observationsimportObservationInfo>>># Find some observations>>>results=search_observations(by_name='M42')>>># Use last result entry to create ObservationInfo object.>>>obs_info=ObservationInfo(meta=results.iloc[0])>>>obs_info.metacamera_id14d3bdcamera_lens_serial_numberHA0028608camera_serial_number12070048413coordinates_mount_dec-6.229778coordinates_mount_ra76.0815exptime120.0field_nameWasp35num_images28.0sequence_idPAN001_14d3bd_20180113T052325software_versionPOCSv0.6.0time2018-01-1305:23:25+00:00total_exptime3360.0unit_idPAN001Name:6121,dtype:object>>># Create an ObservationInfo object directly from a sequence_id.>>>obs_info=ObservationInfo('PAN001_14d3bd_20180113T052325')>>># But then there is no metadata:>>>obs_info.meta{}Downloading imagesTheObservationInfoobject makes it easy to download the files:>>>obs_info.download_images()Command-line toolsThere is a simple command line tool that allows for both searching and downloading of images and metadata.Search for observations:$panoptes-datasearch--nameM42--min-num-images90|sequence_id|field_name|unit_id|coordinates_mount_ra|coordinates_mount_dec|num_images|exptime|total_exptime|time||:------------------------------|:-------------|:----------|-----------------------:|------------------------:|-------------:|----------:|----------------:|:--------------------------||PAN022_977c86_20220108T090553|M42|PAN022|83.8221|-5.39111|95|90|8550|2022-01-0809:05:53+00:00||PAN022_538cc6_20220108T090553|M42|PAN022|83.8221|-5.39111|95|89|8455|2022-01-0809:05:53+00:00||PAN019_42433a_20220114T085722|M42|PAN019|83.8221|-5.39111|90|90|8100|2022-01-1408:57:22+00:00||PAN019_c623e9_20220114T085722|M42|PAN019|83.8221|-5.39111|90|89.0222|8012|2022-01-1408:57:22+00:00||PAN019_c623e9_20220115T082108|M42|PAN019|83.8221|-5.39111|105|89.019|9347|2022-01-1508:21:08+00:00||PAN019_42433a_20220115T082108|M42|PAN019|83.8221|-5.39111|105|90.0095|9451|2022-01-1508:21:08+00:00|Downloading all images for an observation:panoptes-datadownloadPAN022_977c86_20220108T090553Get all metadata for a unit in a given date range:panoptes-dataget-metadata--unit-idPAN022--start-date'2022-01-08'Seepanoptes-data --helpfor more options.
Package: panoptes-utils
PANOPTES UtilitiesUtility functions for use within theProject PANOPTESecosystem and for general
astronomical processing.This library defines a number of modules that contain useful functions as well as a few services.InstallTo install type:pipinstallpanoptes-utilsFull options for install:pipinstall"panoptes-utils[config,docs,images,testing,social]"See the full documentation at:https://panoptes-utils.readthedocs.ioDependenciesThere are a few system dependencies depending on what functionality you will be using.In particular, the plate solving requiresastrometry.netand the appropriate index files.Use the following on a debian-based system (e.g. Ubuntu) to easily install all dependencies:apt-getupdate&&apt-getinstall--no-install-recommends--yes\libffi-devlibssl-dev\astrometry.netastrometry-data-tycho2\dcrawexiftoollibcfitsio-devlibcfitsio-bin\libfreetype6-devlibpng-devlibjpeg-devlibffi-devCommand LineThepanoptes-utilscommand line tool is available for use with subcommands
corresponding to the modules in this library. Currently, the only implemented
subcommand isimage, which includes commands for convertingcr2files intojpgand/orfitsfiles as well as for plate-solvingfitsimages.Thepanoptes-utils image watch <path>command will watch the given path for
new files and convert them tojpgand/orfitsfiles as they are added.Seepanoptes-utils --helpandpanoptes-utils image --helpfor details.Config ServerThere is a simple key-value configuration server available as part of the module.After installing with theconfigoption as above, type:panoptes-config-serverrun--config-file<path-to-file.yaml>Developingpanoptes-utilsusespyscaffoldfor project setup,
which then uses the standardtoxandpyproject.tomltools to manage the project. Tests can
be run withtox, e.g.# Clean repository.tox-eclean# Run tests.tox# Build project.tox-ebuild
Package: panoptic
PanopticPanoptic is a tool for exploring and annotating large image corpora, using image analysis and machine learning tools to facilitate these tasks.Since it requires deep learning libraries, it is recommended to use it with a computer with minimal computing capabilities.Caution: Panoptic is still in active development and is currently a prototype, it is likely that you will encounter bugs, so we recommend to use this tool only for testing and not to rely on it for a substantial academic work.Pip installation (WIP)pip install panopticpanopticInstallation (development)The following steps involve cloning the directory and are recommended for users who wish to have access to the development versions, or who wish to modify the code themselves in order to contribute.Backend development onlyTo test and modify the backend operation, we provide an already built frontend in the backend html folder.go to thepanoptic-backfolderto install the dependenciespython setup.py installto simply use panopticpip install -e .to developpip install -r requirements.txtand you have to addpanoptic-backto the PYTHON_PATH for developping purpose toorunpython panoptic/main.pyFront and back developmentFirst of all, perform the installation steps of the backendgo to thepanoptic-frontfolderRunnpm install.runnpm run dev.before running the backend thePANOPTIC_ENVenvironment variable should be set toDEVin order to use the development frontend.Windows install (coming soon)Mac installation (coming soon)Linux installation (coming soon)
Package: panoptica
panopticaComputing instance-wise segmentation quality metrics for 2D and 3D semantic- and instance segmentation maps.FeaturesThe package provides three core modules:Instance Approximator: instance approximation algorithms to extract instances from semantic segmentation maps/model outputs.Instance Matcher: matches predicted instances with reference instances.Instance Evaluator: computes segmentation and detection quality metrics for pairs of predicted - and reference segmentation maps.InstallationWith a Python 3.10+ environment, you can install panoptica frompypi.orgpipinstallpanopticaUse cases and tutorialsFor tutorials featuring various use cases, see:BrainLesion/tutorials/panopticaSemantic Segmentation InputJupyter notebook tutorialAlthough an instance-wise evaluation is highly relevant and desirable for many biomedical segmentation problems, they are still addressed as semantic segmentation problems due to the lack of appropriate instance labels.This tutorial leverages all three modules of panoptica: instance approximation, -matching and -evaluation.Unmatched Instances InputJupyter notebook tutorialIt is a common issue that instance segmentation outputs feature good outlines but mismatched instance labels.
For this case, the matcher module can be utilized to match instances and the evaluator to report metrics.Matched Instances InputJupyter notebook tutorialIf your predicted instances already match the reference instances, you can directly compute metrics using the evaluator module.CitationIf you use panoptica in your research, please cite it to support the development!Kofler, F., Möller, H., Buchner, J. A., de la Rosa, E., Ezhov, I., Rosier, M., Mekki, I., Shit, S., Negwer, M., Al-Maskari, R., Ertürk, A., Vinayahalingam, S., Isensee, F., Pati, S., Rueckert, D., Kirschke, J. S., Ehrlich, S. K., Reinke, A., Menze, B., Wiestler, B., & Piraud, M. (2023).Panoptica -- instance-wise evaluation of 3D semantic and instance segmentation maps.arXiv preprint arXiv:2312.02608.@misc{kofler2023panoptica,
      title={Panoptica -- instance-wise evaluation of 3D semantic and instance segmentation maps}, 
      author={Florian Kofler and Hendrik Möller and Josef A. Buchner and Ezequiel de la Rosa and Ivan Ezhov and Marcel Rosier and Isra Mekki and Suprosanna Shit and Moritz Negwer and Rami Al-Maskari and Ali Ertürk and Shankeeth Vinayahalingam and Fabian Isensee and Sarthak Pati and Daniel Rueckert and Jan S. Kirschke and Stefan K. Ehrlich and Annika Reinke and Bjoern Menze and Benedikt Wiestler and Marie Piraud},
      year={2023},
      eprint={2312.02608},
      archivePrefix={arXiv},
      primaryClass={cs.CV}
}
Package: panopticon
PanopticonPanopticon is a debugger-powered tracer for Python code to quickly visualize and explore code execution. Traces generated areCatapultcompatible — available at `chrome://tracing` if you're using Chrome.Alpha: I'm still working on adding tests, polishing the api, and cleaning up the code in general. Expect the API to change drastically as it meanders towards v1. It should still be immediately useful as a debugging tool. Please report issues if you come across bugs!UsageYou can read a more detailed guide with several examples of simple Python programs, different interfaces to visualize them and the corresponding traces atexplog.in/panopticon.Run a command directlypython3-mpanopticon-c"print('hello')"-oprint_hello.traceRun a filepython3-mpanopticon-ofile.tracefile.pyIn codefrompanopticonimportrecord_tracewithrecord_trace("print_hello.trace"):print("Hello")Probe a specific functionIt can be tricky to control how a program is executed: using the probe decorator allows instrumenting a specific function instead.frompanopticon.probeimportprobefrompanopticon.traceimportStreamingTrace@probe(trace=StreamingTrace(open("probe.trace","w")))defmyfunction():...Asynchronous FunctionsPython supports suspending and continuing execution of a frame through generators, coroutines and asynchronous generators. Panopticon creates "flow" events to connect a single frame executing through time, making it easier to visualize what's actually happening.You can enable/disable connections for different types of functions by choosing to enable/disable flow events in Catapult (top-right).Changelog0.0.4Reimplement probes to be more robust and avoid capturing all contentsSupport for probing functions, coroutines, generators and async generatorsProbes can now write to multiple traces0.0.3Added basic support for capturing arguments in tracesNew utility to "flatten" complex or sparse traces for readabilityImproved naming behavior whenselfis modifiedExtremely basic support for async probes0.0.2Added a simplified record_trace APIAdded support for @probe to instrument functions and classes0.0.1Initial version of PanopticonCLI supports running commands and files for tracing
Package: panoptic-parts
Part-aware Panoptic Segmentationv2.0 Release Candidate[CVPR 2021 Paper] [Datasets Technical Report] [Documentation]This repository contains code and tools for reading, processing, evaluating on, and visualizing Panoptic Parts datasets. Moreover, it contains code for reproducing our CVPR 2021 paper results.DatasetsCityscapes-Panoptic-PartsandPASCAL-Panoptic-Partsare created by extending two established datasets for image scene understanding, namelyCityscapesandPASCALdatasets. Detailed description of the datasets and various statistics are presented in our technical report inarxiv. The datasets can be downloaded from:Cityscapes Panoptic PartsPASCAL Panoptic Parts(alternative link, code: i7ap)ExamplesMore exampleshere.Installation and usageThe code can be installed from the PyPI and requires at least Python 3.7. It is recommended to install it in a Python virtual environment.pipinstallpanoptic_partsSome functionality requires extra packages to be installed, e.g. evaluation scripts (tqdm) or Pytorch/Tensorflow (torch/tensorflow). These can be installed separately or by downloading theoptional.txtfile from this repo and running the following command in the virtual environment:pipinstall-roptional.txtAfter installation you can use the package as:importpanoptic_partsasppprint(pp.VERSION)There are three scripts defined as entry points by the package:pp_merge_to_panoptic<args>
pp_merge_to_pps<args>
pp_visualize_label_with_legend<args>API and code referenceWe provide a public, stable API, and various code utilities that are documentedhere.Reproducing CVPR 2021 paperThe part-aware panoptic segmentation results from the paper can be reproduced usingthisguide.Evaluation metricsWe provide two metrics for evaluating performance on Panoptic Parts datasets.Part-aware Panoptic Quality (PartPQ):here.Intersection over Union (IoU):TBACitationsPlease cite us if you find our work useful or you use it in your research:@inproceedings{degeus2021panopticparts,title={Part-aware Panoptic Segmentation},author={Daan de Geus and Panagiotis Meletis and Chenyang Lu and Xiaoxiao Wen and Gijs Dubbelman},booktitle={IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},year={2021}}@article{meletis2020panopticparts,title={Cityscapes-Panoptic-Parts and PASCAL-Panoptic-Parts datasets for Scene Understanding},author={Panagiotis Meletis and Xiaoxiao Wen and Chenyang Lu and Daan de Geus and Gijs Dubbelman},type={Technical report},institution={Eindhoven University of Technology},date={16/04/2020},url={https://github.com/tue-mps/panoptic_parts},eprint={2004.07944},archivePrefix={arXiv},primaryClass={cs.CV}}ContactPlease feel free to contact us for any suggestions or questions.panoptic.parts@outlook.comThe Panoptic Parts datasets teamCorrespondence: Panagiotis Meletis, Vincent (Xiaoxiao) Wen
Package: panoptisch
Panoptisch: A recursive dependency scanner for Python projects⚠️🚨 Early stage! May not work as expected! Feedback welcome! 🚨⚠️See:Introduction VideoWhat?Panoptisch scans your Python file or module to find it's imports (aka dependencies) and recursively does so for all dependencies and sub-dependencies.
It then generates a dependency tree in JSON for you to parse and enforce import policies.
Imports are resolved by mimicing Python's import system. It's completely static besides the importing of modules to find the location of its source file(s). Panoptisch also features a minimal sandbox to prevent side-effects when importing dependencies. Note that the sandbox is not foolproof!Please NOTE:There are knownlimitations and issuesat this stage. Please read this before using Panoptisch.See:LIMITATIONS.mdLINK.MotivationI was not able to find a proper dependency scanner for Python. Panoptisch was born out of the need to accurately verify dependency usage accross an entire project.It's aim is to generate a JSON report that can be parsed and evaluated toassert import policies.For example, you may want to restrictos,socket,sysandimportlibimports to selected packages.UsageInstallPanoptischin the same virtual environment as your project, this is important!pip install panoptischUseusage: panoptisch <module>

positional arguments:
  module                Name of module or file you wish to scan.

options:
  -h, --help            show this help message and exit.
  --show-stdlib-dir     Prints the automatically resolved stdlib directory.
  --max-depth MAX_DEPTH
                        Maximum dependency depth.
  --out OUT             File to output report.
  --auto-stdlib-dir     Ignore stdlib modules by automatically resolving their path. MAY BE BUGGY. Try running panoptisch <module_name> --show-stdlib-dir to see the directory before using this.
  --stdlib-dir STDLIB_DIR Ignore stdlib modules by providing their path.
  --omit-not-found      Do not include modules that could not be resolved in report.
  --no-sandbox          Ignore the minimal sandbox implementation.A typical run may be$ panoptisch <module or file> --max-depth 5 --omit-not-foundSee report$ more out.jsonWe might not be interested in the dependencies of standard library modules as we place an implicit trust in them.To filter them out, use the--show-stdlib-dirarguement to see if Panoptisch can automatically resolve your standard library directory, typically/usr/local/lib/python3.xon linux installations. Then you can exclude it using$ panoptisch <module or file> --auto-stdlib-dirIf Panoptisch cannot automatically resolve your standard library directory, you can find it yourself and provide it as an argument tostdlib-dir$ panoptisch <module or file> --stdlib-dir /the/path/to/your/standardlibrary/LICENSEAll work is licensed under theGNU General Public License Version 3.ContributingFeedback, contributions and issues welcome.