Saravanan666/pypi-org huggingface dataset:
Package: zepben.eas
Evolve App Server Python ClientThis library provides a wrapper to the Evolve App Server's API, allowing users of the evolve SDK to authenticate with
the Evolve App Server and upload studies.UsagefromgeojsonimportFeatureCollectionfromzepben.easimportEasClient,Study,Result,Section,GeoJsonOverlayeas_client=EasClient(host="<host>",port=1234,client_id="<client_id>",username="<username>",password="<password>",client_secret="<client_secret>")eas_client.upload_study(Study(name="<study name>",description="<study description>",tags=["<tag>","<tag2>"],results=[Result(name="<result_name>",geo_json_overlay=GeoJsonOverlay(data=FeatureCollection(...),styles=["style1"]),sections=Section(type="TABLE",name="<table name>",description="<table description>",columns=[{"key":"<column 1 key>","name":"<column 1 name>"},{"key":"<column 2 key>","name":"<column 2 name>"},],data=[{"<column 1 key>":"<column 1 row 1 value>","<column 2 key>":"<column 2 row 1 value>"},{"<column 1 key>":"<column 1 row 2 value>","<column 2 key>":"<column 2 row 2 value>"}]))],styles=[{"id":"style1",# other Mapbox GL JS style properties}]))eas_client.close()AsyncIOAsyncio is also supported using aiohttp. A session will be created for you when you create an EasClient if not provided via thesessionparameter to EasClient.To use the asyncio API useasync_upload_studylike so:fromaiohttpimportClientSessionfromgeojsonimportFeatureCollectionfromzepben.easimportEasClient,Study,Result,Section,GeoJsonOverlayasyncdefupload():eas_client=EasClient(host="<host>",port=1234,client_id="<client_id>",username="<username>",password="<password>",client_secret="<client_secret>",session=ClientSession(...))awaiteas_client.async_upload_study(Study(name="<study name>",description="<study description>",tags=["<tag>","<tag2>"],results=[Result(name="<result_name>",geo_json_overlay=GeoJsonOverlay(data=FeatureCollection(...),styles=["style1"]),sections=Section(type="TABLE",name="<table name>",description="<table description>",columns=[{"key":"<column 1 key>","name":"<column 1 name>"},{"key":"<column 2 key>","name":"<column 2 name>"},],data=[{"<column 1 key>":"<column 1 row 1 value>","<column 2 key>":"<column 2 row 1 value>"},{"<column 1 key>":"<column 1 row 2 value>","<column 2 key>":"<column 2 row 2 value>"}]))],styles=[{"id":"style1",# other Mapbox GL JS style properties}]))awaiteas_client.aclose()
Package: zepben.evolve
Zepben Evolve Python SDKThe Python Evolve SDK contains everything necessary to communicate with aZepben EWB Server. See the completeEvolve Python SDK Documentationfor more details.Note this project is still a work in progress and unstable, and breaking changes may occur prior to 1.0.0.RequirementsPython 3.7 or laterInstallationpip install zepben.evolveBuildingpython setup.py bdist_wheelUsageSeeEvolve Python SDK Documentation.
Package: zepben.evolve.test-ci-central
Zepben Evolve Python SDKThe Python Evolve SDK contains everything necessary to communicate with aZepben EWB Server. See the completeEvolve Python SDK Documentationfor more details.Note this project is still a work in progress and unstable, and breaking changes may occur prior to 1.0.0.RequirementsPython 3.7 or laterInstallationpip install zepben.evolveBuildingpython setup.py bdist_wheelUsageSeeEvolve Python SDK Documentation.
Package: zephir
ZephIR is a multiple object tracking algorithm based on image registration and built on PyTorch. Check out ourpreprintandtutorial video!Latest Updates in v1.0.4bug fixes for deprecated dependenciesseerelease notesfor full list of changesAboutZephIR tracks keypoints in a 2D or 3D movie by registering image descriptors sampled around each keypoint.
Image registration loss is combined with three additional regularization terms:spring connections between neighboring objects allow a flexible spatial model of loosely correlated motionfeature detection optimizes results towards centers of detected featurestemporal smoothing of pixel intensity a small patch of frames limit fluctuations in activityOverview of tracking loss:ZephIR is fast, efficient, and designed to run on laptops instead of powerful desktop workstations.
It requires no prior training of any model weights, and it is capable of generalizing to a wide diversity of datasets with small tweaks to parameters.
This makes ZephIR ideal for analyzing datasets that lack a large corpus of training data, and for tracking fluorescent sources in moving and deforming tissue, both of which create a particularly challenging environment for modern deep learning techniques.
ZephIR can also serve as a data augmentation tool in some cases.
We provide some support for exporting ZephIR results toDeepLabCut.InstallationQuick startpipinstalldocoptflask==2.1.2pandas==1.4.2zephirDependenciesMake sure thatPython (>=3.8.1)and the following packages are installed (prefer conda over pip):dataclasses (>=0.6)docopt (>=0.6.2)Flask (>=2.1.2)gevent (>=21.12.0)h5py (>=3.6.0)matplotlib (>=3.5.2)numpy (>=1.22.4)opencv-python (>=4.5.5.64)pandas (>=1.4.2)pathlib (>=1.0.1)scikit-learn (>=1.0.2)scikit-image (>=0.19.2)scipy (>=1.7.3)setuptools (>=61.2.0)torch (>=1.10.0) (seePyTorch.orgfor instructions on installing with CUDA)tqdm (>=4.64.0)NOTE: If you run into an issue when launching the annotator, you may need to downgradeFlask(2.1.2) andPandas(1.4.2).Build from sourceClone git repository:gitclonehttps://github.com/venkatachalamlab/ZephIR.gitNavigate to the cloned directory on your local machine.Checkout the current release:gitcheckoutv1.0.4Use the following command to see what's new in the most recent release:gitshowv1.0.4Install:pythonsetup.pyinstallor install in development mode:pythonsetup.pydevelopGetting StartedRun from command line:zephir--dataset=.[options]We provide a detailed guide for running ZephIR as well as some example workflows for using ZephIRhere.ParametersFor a list of all CLI options and user-tunable parameters, seehere.To help figure out what options may be right for you, check out the list of examples with explanations for the chosen parametershere.Interfacing with AnnotatorZephIR includes an annotator GUI with custom Python macros for interacting with the data from the GUI.Run from command line:annotator--dataset=.[--port=5000]Learn more about the annotator and its featureshere.We also provide a more detailed user guide for using the GUI as a part of a ZephIR workflowhere.
Package: zephserver
# Zephserver
## Python service manager that can be used as a WebSocket serverZephserver is a python service manager that can be used in a cluster.
It has been written to support a websocket server but it can be used for any other stuff needing full time services or cluster management.More documentation on how the server works [here](http://zephserver.readthedocs.org/en/latest/)## QuickstartTo use zephserver you will need python 2.7. It should not work on python 3 and a Unix incompatible system.### Quickstart as service manager(use zephserver as a websocket server bellow)#### 1.Install zephserver from pippip install zephserver#### 2.Create your foldermkdir myserver#### 3.Add the configuration filetake zephsettings.py file from the example folder.the variable heart_beat_period, PORT_ZEPH and TASKS_PATH are not usedempty the service list(these services are made for the websocket server)#### 4.Add the starter fileCopy zephstarter_no_django.py file in your folder#### 5.Write your servicesread the zephserver/service/service_interface.py file to know the minimum interface you have to implement.#### 6.Register your serviceAdd your service to the SERVICE_LIST variable.Respect the syntaxmy_server.my_package.my_service/MyServicesyntaxe.example for the service_interface it would be‘zephserver.service.service_interface/ServiceInterface’nota : there is no need for the service object to have the same name as its file and there can be multiple services in a file.#### 7.Start your serverTo start your server in the current shell, simply call :python zephstarter_no_django.py.tips: to not lock your shell user the ` &` modifier at the end of the command.#### 8.Stop your serverto stop your server callzephserver-stop /path/to/the/folder/interface.sockIf the server died without the zephserver command (crash) you will have to remove the server.lock file.### Quickstart as websocket server#### 1.Install zephserver from pippip install zephserverIf you wants to use django services (db_service and session backend with django) install django(only version 1.7 is supported)#### 2.Create your foldermkdir myserverif you use django myserver will simply refer to the django site folder#### 3.Add the configuration filetake zephsettings.py file from the example folder.#### 4.Add the starter fileIf you use django Copy the zephstarter.py file and adpt it to your application otherwise copy zephstarter_no_django.py file in your folder#### 7.Start your serverTo start your server in the current shell, simply call :python zephstarter.py.tips: to not lock your shell user the ` &` modifier at the end of the command.#### 8.Stop your serverto stop your server callzephserver-stop /path/to/the/folder/interface.sockIf the server died without the zephserver command (crash) you will have to remove the server.lock file.
Package: zephyrion
Zephyrion - DeprecatedNote: This repository is deprecated and no longer maintained. For an active and maintained browser automation library, we recommend usingQuokka.Zephyrion is a powerful Python library built on top of Pyppeteer, designed to simplify browser automation and manipulation tasks. It provides a convenient way to interact with web pages, extract data, and automate browser actions.Deprecation NoticeThis repository is no longer actively maintained. We encourage you to consider usingQuokka, a modern and actively developed browser automation library that offers a rich set of features and improved performance.Key FeaturesEasy Browser Management: Zephyrion provides a simple interface for managing browser instances, starting, stopping, and navigating web pages.Data Extraction: With the data extraction module, you can easily extract data from web pages using customizable selectors and patterns.Page Interaction: The page interaction module enables you to interact with web page elements, such as clicking, typing, and scrolling.Extensible: Zephyrion's architecture allows for extension and customization to suit your specific needs.InstallationpipinstallzephyrionGetting StartedZephyrion's intuitive API makes browser automation straightforward. Here's a simple example:fromzephyrionimportBrowserasyncdefmain():browser=awaitBrowser.launch(headless=True)page=awaitbrowser.new_page()awaitpage.goto("https://example.com")# Your automation code hereawaitbrowser.close()if__name__=="__main__":importasyncioasyncio.run(main())DocumentationFor detailed usage instructions, examples, and customization options, please refer to the Documentation.ExamplesCheck out the Examples folder for more usage scenarios and demonstrations of Zephyrion's capabilities.ContributingContributions to Zephyrion are welcome! Please read our Contribution Guidelines for more information on how to contribute to the project.LicenseThis project is licensed under the MIT License.
Package: zephyr-python-api
Zephyr-python-apiProject descriptionThis is a set of wrappers for Zephyr Scale (TM4J) REST API. This means you can interact with Zephyr Scale without GUI, access it with python code and create automation scripts for your every day interactions.To be done:More usage examplesTests, tests and tests for gods of testingConvenient docsImplementing higher level wrappers representing Test Case, Test Cycle, etc.Installationpip install zephyr-python-apiExample usageZephyr Cloud auth:fromzephyrimportZephyrScalezscale=ZephyrScale(token=<your_token>)Zephyr Server (TM4J) auth:fromzephyrimportZephyrScale# Auth can be made with Jira tokenauth={"token":"<your_jira_token>"}# or with login and password (suggest using get_pass)auth={"username":"<your_login>","password":"<your_password>"}# or even session cookie dictauth={"cookies":"<session_cookie_dict>"}zscale=ZephyrScale.server_api(base_url=<your_base_url>,**auth)Then it is possible to interact with api wrappers:zapi=zscale.api# Get all test casesall_test_cases=zapi.test_cases.get_test_cases()# Get a single test case by its idtest_case=zapi.test_cases.get_test_case("<test_case_id>")# Create a test casecreation_result=zapi.test_cases.create_test_case("<project_key>","test_case_name")TroubleshootingFor troubleshooting seeTROUBLESHOOTING.mdLicenseThis library is licensed under the Apache 2.0 License.LinksZephyr Scale Cloud API docsZephyr Scale Server API docs
Package: zephyr-rtsp
ZephyrZephyr is a simple RTSP library to stream and receive video over RTSP.Pre-requisitesPython 3.8 or higherFFmpegto encode and decode videoMediaMTXas RTSP serverInstallationThe easiest way to install Zephyr is using pip:$pipinstallzephyr-rtspBut you can also install Zephyr from source:$gitclonehttps://github.com/bpradana/zephyr.git
$cdzephyr
$pythonsetup.pyinstallUsageZephyr has 2 main classes,StreamandClient.Streamis used to stream video over RTSP, whileClientis used to receive video from RTSP stream.StreamTo stream video, you need to create aStreamobject and callsendwith a frame. You can also callendto stop the stream.importcv2fromzephyrimportStreamif__name__=="__main__":stream=Stream(url="rtsp://localhost:8554/test",resolution=(1280,720),fps=30,bitrate="2M")cap=cv2.VideoCapture(0)whileTrue:ret,frame=cap.read()stream.send(frame)ClientTo receive video, you need to create aClientobject and callreadto get the frame. You can also callreleaseto stop receiving video.importcv2fromzephyrimportClientif__name__=="__main__":client=Client(url="rtsp://localhost:8554/test")whileTrue:ret,frame=client.read()cv2.imshow('frame',frame)ifcv2.waitKey(1)&0xFF==ord("q"):client.release()breakLicenseZephyr is licensed under theMIT License.CreditsZephyr usesFFmpegto encode and decode video.The name Zephyr is inspired byZephyra video streaming project byOctavia.
Package: zephyr-seis
# Zephyr[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/uwoseis/zephyr/blob/master/LICENSE)
[![Travis Status](https://travis-ci.org/uwoseis/zephyr.svg?branch=master)](https://travis-ci.org/uwoseis/zephyr)
[![Coverage Status](https://coveralls.io/repos/uwoseis/zephyr/badge.svg?branch=master&service=github)](https://coveralls.io/github/uwoseis/zephyr?branch=master)
[![Code Issues](https://www.quantifiedcode.com/api/v1/project/02a2dbe184e04d1482daa174e9973501/badge.svg)](https://www.quantifiedcode.com/app/project/02a2dbe184e04d1482daa174e9973501)Open-source seismic waveform modelling and inversion code written in PythonProject site: [https://zephyr.space](https://zephyr.space)Auto docs: [https://zephyr.space/api/zephyr.html](https://zephyr.space/api/zephyr.html)## AuthorsBrendan Smithyman <[brendan@bitsmithy.net](mailto:brendan@bitsmithy.net)>Shaun Hadden <[shadden2@uwo.ca](mailto:shadden2@uwo.ca)>
Package: zepl
ZeplConsole application for MicroPython WebREPLUsageSet up WebREPL on your board(s).$ zepl 192.168.0.87 8266 -p <password>
---  Quit: Ctrl+A followed by Ctrl+X  |  Help: Ctrl+A followed by h  ---

<Ctrl+A followed by h>

--- zmq (18.0.1) - zepl - help
---
--- Micropython hotkeys
--- Ctrl+C Micropython Keyboard Interrupt
--- Ctrl+D Micropython Soft Reset
---
--- Ctrl+A Menu escape key
--- Menu keys:
---    Ctrl+A Send the menu character itself to remote
---    Ctrl+E encoding
---    Ctrl+F edit filters
---    Ctrl+L EOL mode
---    Ctrl+X Exit program
---    h Show help
---    r Micropython Machine Reset
---    v Get Version
---    l List files
---    u Upload file (prompt will be shown)
---    d Download file (prompt will be shown)


WebREPL connected
>>> 

<Ctrl+A followed by Ctrl+X>

--- exit ---$ zepl -h
Usage: zepl [-h] [-p PASSWORD] [--encoding CODEC] [-f NAME]
            [--eol {CR,LF,CRLF}] [--raw] [--menu-char NUM] [--exit-char NUM]
            [-q]
            [ip] [port]

Zepl - A simple remote terminal program for Micropython webREPL

positional arguments:
  ip                    hostname or ip
  port                  set port, default: 8266

optional arguments:
  -h, --help            show this help message and exit

data handling:
  -p PASSWORD, --password PASSWORD
                        Password for WebREPL login
  --encoding CODEC      set the encoding for the serial port (e.g. hexlify,
                        Latin1, UTF-8), default: UTF-8
  -f NAME, --filter NAME
                        add text transformation
  --eol {CR,LF,CRLF}    end of line mode
  --raw                 Do no apply any encodings/transformations

hotkeys:
  --menu-char NUM       Unicode code of special character that is used as menu
                        key, default: Ctrl+A
  --exit-char NUM       Unicode code of special character that is used as exit
                        key, default: Ctrl+X

diagnostics:
  -q, --quiet           suppress non-error messagesDocumentationread thestory
Package: zepl-broker
Zepl Brokerinstall:pip install zepl-brokerquick testissue all commands in the same terminal!start the broker, log listener and dummy in the background$ zepl-broker &
-- Starting Zepl Broker --

$ zepl-client log &
-- Starting Zepl Client --

$ zepl-client -d --config dummy.json ctrl add &
-- Starting Zepl Client --
ZeplDevice initialized.
Added dummy1: :  [b'success']say hello!$ zepl-client -d dev greet dummy1
-- Starting Zepl Client --
greeting dummy1 runner -- :  [b'why hello there!']
greeting dummy1 device -- :  [b'not sure if...']
b'dummy1' -- b'DUMMY_DEV_RAW_OUT' --  b'why hello there!'kill them all$ kill $(jobs -p)
[1]   Terminated              zepl-broker
[2]-  Terminated              zepl-client log
[3]+  Terminated              zepl-client -d --config dummy.json ctrl addfor more see:examplesanddoccaveatat this moment the command line tool is very picky about the arguments
Package: zepl-logging
Zepl LoggingThis package let's you do logging just like a basic logging modeule but it is desiged specifically to work with zepl notebooks as those are containerized so all the logs are lost when the container is shut down.InstallationYou can install zepl_logging package fromPyPI:pip install zepl_loggingThe project is Suported with Python 3+How to usefrom zepl_logging import logging

logger = logging.Logging()

logger.base_config('your_zepl_token', notebook='notebook_name', organization='org_name')

#now you can use this logger to log anything like 

logger.info('Connected to Db!')
logger.debug('This is a debug message!')
Package: zeplyn
ZeplynUsageZeplyn allows to you release python package fastly and easily in one command:zeplyn publishYou should run that command in your command prompt in the folder directory where you want to put your packageZeplyn also have azeplyn createcommand which automatically create a readme file, a setup.py file and a src folder where your package's code is going to be stored.Full documentation here :https://github.com/ssantoshp/zeplyn
Package: zeppelin-handy-helpers
# zeppelin-handy-helpersConsole helper to check, monitor, stop zeppelin paragraph and receive notifications to Slack[![Build Status](https://travis-ci.org/sbilello/zeppelin-handy-helpers.svg?branch=master)](https://travis-ci.org/sbilello/zeppelin-handy-helpers)[![CircleCI](https://circleci.com/gh/sbilello/zeppelin-handy-helpers.svg?style=svg)](https://circleci.com/gh/sbilello/zeppelin-handy-helpers)[![PyPI version](https://badge.fury.io/py/zeppelin-handy-helpers.svg)](https://badge.fury.io/py/zeppelin-handy-helpers)### DisclaimerThis tool is just a small helper and it is not ready for production yet. It works pretty well for my use cases. Feel free to expand or improve.### Installation```pip install zeppelin-handy-helpers```### Usage```usage: zhh [-h] [--end_point [END_POINT]][--slack_end_point [SLACK_END_POINT]] [--read] [--check] [--stop][--monitor]optional arguments:-h, --help            show this help message and exit--end_point [END_POINT]Specify Zeppelin API end_point--slack_end_point [SLACK_END_POINT]Specify Slack Incoming Webhook--read                Show all notebook names and ids--check               Show all running paragraphs--stop                Stop all runnning paragraphs--monitor             Monitor all running paragraphs```### Examples```(demo) ➜  zeppelin-handy-helpers git:(master) ✗ zhh --end_point http://localhost/api/notebook --slack_end_point https://hooks.slack.com/services/XXXXX/XXXX/XXXXX --read[{"id": "2CFH4E3TG","name": "OWL"},{"id": "2CF34ERK6","name": "SparkPi"},{"id": "2D62499YH","name": "DemoNotebook"}]Execution completed```
Package: zeppy
distributed processing for eppyyFree software: Mozilla Public License 2.0 (MPL-2.0)Documentation:https://zeppy.readthedocs.io.VisionTo run eppy on multiple nodes in parallel and collect the results.So what is a node and why would you want to do this ?A node can be any or all of the following:a process (such E+ running on a single core on a multi-core computer)so we can do multi-processing and run it on many cores on a single computera computerso we can run it on multiple computers that are on the same networka group of computer in a local networkSo we can run multiple groups of machines that may be at different locations on different local networksThis can also be computers at different cloud locationsa single computer in the local network may act as an access nodeFeaturesDo the distributed processing with a single function call and get all the results back.Sample codeimport zeppy import ppipes

result = ppipes.ipc_parallelpipe(runfunction,
                                args_list,
                                nworkers=None)

# runfunction is a function you will write,
    # that may run idf.run(),
    # gather the total energy use and return it
# args_list = {args: [idf1, idf2, idf3, ...]}
    # list of files to run
# if nworkers=None:
    # it will start up as many nodes as there are items in args_list
    # if you don't have enough nodes avaliable, you can set nworkers=n.
    # it will start up n nodes and queue up the runs evenly on the nodesFor example the above code can do the following:runfunctionwill run theidffile, and return thetotal energy usageresultwill be a listtotal energy usagein the same order as the items inargs_listsee the comments in the code for greater clarityCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: zep-python
Zep: Fast, scalable building blocks for LLM appsChat history memory, embedding, vector search, data enrichment, and more.Quick Start|Documentation|LangChainandLlamaIndexSupport |Discordwww.getzep.comWhat is Zep?Zep is an open source platform for productionizing LLM apps. Zep summarizes, embeds, and enriches chat histories and documents asynchronously, ensuring these operations don't impact your user's chat experience. Data is persisted to database, allowing you to scale out when growth demands. As drop-in replacements for popular LangChain components, you can get to production in minutes without rewriting code.Zep Python ClientThis is the Python client package for the Zep service. For more information about Zep, seehttps://github.com/getzep/zep.Zep QuickStart Guide:https://docs.getzep.com/deployment/quickstartZep Documentation:https://docs.getzep.comInstallationpipinstallzep-python-- OR --poetryaddzep-python
Package: zeptron
zeptron live streaming to any server / port using TCPThis package provides the code to stream from webcam, USB camera, or Raspberry Pi to any IP address and port number.InstallationSimple install the package using:pip install zeptronUseThen run it using the following command:zeptron -i IP_ADDRESS -p PORTThe flags are as follows:-i / --ipIP address of server, required-p / --portPort of server, required, use 5555 as default-r / --raspberryIf streaming from Raspberry Pi, set to True, else do not useIntended purposeThis library is intended to be used with thezeptron.comodel-agnostic platform for using artificial intelligence models for computer vision, although you can use it for any project where you need a super low-latency, high definition feed and want to avoid paying Amazon ridiculous fees for using Amazon Kinesis VideoCreditsThis package borrows heavily from:ZeroMQImageZMQ