package
stringlengths 1
122
| pacakge-description
stringlengths 0
1.3M
|
|---|---|
zendesk_api | UNKNOWN |
zendeskclient | zendeskclientA lightweight ZenDesk REST API client written in Python.Usagefrom zendeskclient import ZenDeskClient
client = ZenDeskClient(‘[email protected]’, ‘acme-software.zendesk.com’, password=’hunter2’)
all_tickets = client.core.tickets.get()LICENSEMIT LicenseCopyright (c) 2016 CloudBolt SoftwarePermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. |
zendesk-client | No description available on PyPI. |
zendesk-django-auth | Allows your Django App to be used as an authentication platform for your Zendesk AccountZendesk API Documentationseehttp://www.zendesk.com/support/api/remote-authenticationfor ZenDesk Documentation.This module is specifically for Zendesk API v1Installationzendesk_auth version 0.0.3+ works with django 1.5 and abovepip install zendesk-django-authUsageUsing Zendesk SSO in your app is extremely simple…in your settings.py, add ‘zendesk_auth’ to yourINSTALLED_APPSThen add the following two settingsZENDESK_URL=https://your_domain.zendesk.comZENDESK_TOKEN=you_zendesk_tokenNext, add this (or equivalent) to your urls.py:url(r’’, include(‘zendesk_auth.urls’)),You’ll need to setup your zendesk remote authentication settings to allow/use your zendesk_authorize view.You’re done! Now watch it work. |
zendesk-exporter | zendesk_exporterExports data from Zendesk API to excel or csvInstallOpen a command prompt and runsudo easy_install pippip is a tool that lets python developers share code.Now, runpip install zendesk_exporterThis installs the exporter to your computerNow, runzendesk_exporter job_file.jsonjob_file.jsonis a file that the program needs to be able to find.job_file.jsonshould look like this:{"domain_name":"XXX","email":"XXX","api_key":"XXX","start_date":"2018-06-27","end_date":"2018-06-30","fetch_comments":true,"output_file_name":"last_6_months","output_file_type":"csv","fetch_all_ticket_data":false}You can change the parameters in this file to change how the program behaves. |
zendeskhc | python module for interacting with the zendesk help center apiExample CodeHere’s a simple example for using the module.from zendeskhc.HelpCenter import HelpCenter
hc = HelpCenter("https://mysubdomain.zendesk.com")
categories = hc.list_all_categories()
sections = hc.list_all_sections() |
zendesk-help-center-backer | A Zendesk help center backer written in Python |
zendesk_integration | TODO: Modify the whole file as necessary.This is a “long description” file for the package that you are creating.
If you submit your package to PyPi, this text will be presented on thepublic pageof your package.Note: This README has to be written usingreStructured Text, otherwise PyPi won’t format it properly.InstallationThe easiest way to install most Python packages is viaeasy_installorpip:$ easy_install zendeskUsageTODO: This is a good place to start with a couple of concrete examples of how the package should be used.The boilerplate code provides a dummymainfunction that prints out the word ‘Hello’:>> from zendesk import main
>> main()When the package is installed viaeasy_installorpipthis function will be bound to thezendeskexecutable in the Python installation’sbindirectory (on Windows - theScriptsdirectory). |
zendesk-redactor | # zendesk-redactorzendesk-redactoris a command-line interface for the Zendesk [Ticket
Redaction](https://www.zendesk.com/apps/support/ticket-redaction/) app.## MotivationThe usability of the Ticket Redaction app is not so good. The redaction form does not support submitting multi-line
input, so if you have multiple text snippets that you need to redact, you’d have to input them into the field and click
theRedactbutton for each of them separately, one-by-one. This is very inefficient and time-consuming.This tool tries to remedy this usability oversight by allowing you to redact multiple text snippets at once by either
providing them as command-line arguments, or by writing them into a file and supplying the path to this file as a
command-line option.The tool also allows you to redact attachments, although it is currently not possible to do this selectively - it’s
either all of them or none of them.This tool is not a silver bullet though. If you have many text snippets that you need to redact, picking them out of the
ticket is still a cumbersome manual process. But this tool will at least allow you to redact all of them at once,
instead of clickingRedactfor each of them separately.## InstallationIt’s Python, so make sure you have Python 3 installed, and run:` $ pip installzendesk-redactor`Although not strictly necessary, you might want to either create a virtualenv or use something like
[pipx](https://github.com/pipxproject/pipx).## Usage### AuthenticationIn order to authenticate to Zendesk API you must provide the organization name, which usually is the subdomain part of
your Zendesk URL beforezendesk.com(e.gobscuraforhttps://obscura.zendesk.com), your agent email address, and
an API [token](https://developer.zendesk.com/rest_api/docs/support/introduction#using-a-zendesk-api-token).These can be provided in two ways.As command-line options:` $ zredactor--organizationobscura--emailagent@obscura.com--tokenBigSecret42 `As environment variables:` export ZREDACTOR_ORGANIZATION=obscura export [email protected] export ZREDACTOR_TOKEN=BigSecret42 `### Redacting text snipetsThe following command will redact all occurrences of the text snippetsfoo,bar,bazin the ticket with ID 1742:` $ zredactor--organizationobscura--emailagent@obscura.com--tokenBigSecret42--ticket-id1742 snippets foo bar baz `Alternatively, if you use environment variables for authentication:` $ zredactor--ticket-id1742 snippets foo bar baz `The following command will redact all occurrences of the text snippets provided in a file/tmp/to_redact.txtin the
ticket with ID 1742:` $ zredactor--organizationobscura--emailagent@obscura.com--tokenBigSecret42--ticket-id1742 snippets-f/tmp/to_redact.txt `Alternatively, with authentication environment variables set:` $ zredactor--ticket-id1742 snippets-f/tmp/to_redact.txt `The file must contain one snippet per line.### Redacting attachmentsThe following command will redact all attachments in ticket with ID 1742:` $ zredactor--organizationobscura--emailagent@obscura.com--tokenBigSecret42--ticket-id1742 attachments `Alternatively, with authentication environment variables set:` $ zredactor--ticket-id1742 attachments `Note that currently it is not possible to redact attachments selectively. |
zendesk-sell-firehose-client | Zendesk Sell Firehose ClientClient for ZenDesk Sell Firehose APIInstallationpipinstallzendesk_sell_firehose_clientUsagefromzendesk_sell_firehose_clientimportZendeskSellFirehoseClientclient=ZendeskSellFirehoseClient(bearer_token="{BEARER_TOKEN_HERE}")# Get all leadsleads=client.get_leads()DevelopmentSetuppipinstall-rrequirements.txtTestingpytest |
zendesk-ticket-viewer | Still in development - please refer to readme for more informationhttps://github.com/LouisKnuckles/Zendesk_Ticket_ViewerCurrent featuresView all ticketsView a single ticket |
zen_document_parser | # Zen Document Parser## Introzen_document_parser is a utility for extracting data from various official documents. It uses [PDFQuery](https://github.com/jcushman/pdfquery) behind the scenes.Currently, there is out-of-the-box support for parsing **Indian Government ITR-V PDF documents.**The library also supports parsing of arbitrary PDF documents by allowing you to specify a 'schema' for the document. The library allows for multiple 'variants' of a document. For example, The Indian ITR-V document has slightly different fields and layout depending on whether it was generated in 2013, 2014, 2015 etc.Check out the examples below.## InstallationInstall using [pip](https://pip.pypa.io/en/stable/installing/) like so:```bash$ pip install zen_document_parser```## Usage### ITR-V Docs```pythonfrom zen_document_parser.itr.itr import ITRVDocument# You can pass in a path or a file-like object during instantiation.doc = ITRVDocument('/path/to/itrv.pdf')# Will load the file, auto-detect the variant and perform extraction of all# fields and store results internally.doc.extract()# Extracted fields are available in the `data` property.print(doc.data.company_name)print(doc.data.gross_total_income)```### Configuring for custom PDF documentsYou basically follow these steps:- Define one or more 'schemas', ie. `DocVariant` subclasses, to go with each variant of the doc.- In each of these variants, define a `check_for_match()` method that returns `True` if a file was successfully parsed.- Make sure to define `test_fields` as an attribute on each class that is a list of all field names used inside `check_for_match()`. (This is required at present for optimization purposes, but will not be a requirement in an upcoming version.)- Define a `Doc` subclass that represents your document. In the `variants` attribute, specify possible variants.```pythonfrom zen_document_parser.base import DocField, DocVariant, Documentclass Variant1(DocVariant):# The fields that are used inside `check_for_match()`. (for optimization)test_fields = ['form_title']form_title = DocField((30, 300, 500, 380))name = DocField((100, 120, 400, 140.5))address = DocField((150, 90, 650, 110))def check_for_match(self):if self.form_title == 'Application Form For 2014':return Truereturn Falseclass Variant2(DocVariant):test_fields = ['form_title']form_title = DocField((30, 290, 500, 380))name = DocField((70, 140, 350, 160))address = DocField((150, 120, 650, 140))pan_no = DocField((150, 80, 650, 100))def check_for_match(self):if self.form_title == 'Application Form For 2015-16':return Truereturn Falseclass MyForm(Document):variants = [Variant1, Variant2]def main():doc = MyForm('/path/to/form.pdf')doc.extract()print(doc.data.to_dict())```# TODO- Hanle data-type specification- Handle fields being mandatory/non-mandatory.- Right now the user has to explicitly specify `test_fields` for optimization purposes. Find a way where this isn't needed.- Automatically load them the first time they're referred to? `extract()` can still be there as a way to bulk-load all fields in one go. |
zendron | ShowcaseHere we show howzendronenables a writing workflow from within VsCode.First we show how you can structure a paper using note references in Dendron.Installzendronand import references from the relevant Zotero library.Cite while you write, and view all relevant Zotero metadata, annotations, and comment notes with hover.Compile paper to.docx,.pdf, and.htmlwith Pandoc.Find relevant papers via VsCode search.IntroductionThis package was developed for porting Zotero annotations and metadata to markdown. This is made possible withpyzotero. These markdown notes are then brought into aDendronhierarchy for integration with vault notes. Zendron is designed to be used withVisual Studio Codebut is editor agnostic... in theory. The end goal is to get a two way sync between notes in Zotero and notes in Dendron, but this has some difficulties and limitations. For now only a one way sync from Zotero to Dendron is supported.Install InstructionsIt is recommended to build a virtual environment for installation. I've usedconda envduring development.InstallDendron CLIthis is needed for note import into Dendron.Install node jsFor more information you can check outDendron node install instructionnpm install -g @dendronhq/[email protected] use the global flag, but you can alternativley install a specific version for a given workspace.Newer version are not working, waiting on any response togithub issueInstall the zendronpython -m pip install zendronZotero Local SetupTo start you needBetter BibTeX for ZoteroThis allows pinning of bibtex keys. A stable bibtex key is necessary for predictable behavior withinzendron.Go toZotero > Settings... > Advanced > General > Config EditorAccept the risks.In the Search, typeautoPinDelayand change the integer value from 0 (default) to 1. Click OK.This will automatically pin any new publications coming into your zotero database. For previous citations that are not yet pinned, you can highlight all metadata, right click and selectBetter BibTex > Pin BibTeX key. This will make your entries compatible with Zendron. This is a one time thing, after setting theautoPinDelay, you won't need to worry about this.Zotero API keyVisit here to setup aZotero API key.We recommend setting up your Zotero API key with the following settings to allow for full functionality.Personal LibraryAllow library access.Allow notes access.Allow write access.Default Group PermissionsRead/WriteThis key can then be copy-pasted in the configuration file,"config.yaml". You should add your key to.gitignoreto prevent others from accessing your Zotoero database. If the key is lost you can always generate a new one.Basic Usage🚨THE MOST IMPORTANT THING🚨 - When you anyzendroncommand make sure that you have a clean working directory. Meaning rungit status, and make sure there are no untracked files or files to commit. This makes it very easy to revert modifications made byzendronwhile we still work out the kinks.There is 1 command, and 3 optional flags.zendronThis command should only be run in the root directory of the workspace.This command imports notes according to a definedconfig.yaml. Once the command is run the first time the user needs to modify their configuration./conf/zendron/config.yaml. All required configs are marked with a comment# STARTER CONFIGupon initialization.Notes are imported with a## Time Createdheading. This allows for stable reference from other notes, within the note vault. We autogenerate a*.comments.mdthat should be used for taking any additional notes within Dendron. Additional notes taken within the meta data file (notes/zendron.import.<paper-title>.md), or the*.annotations.mdwill be overwritten after runningzendron -rmorzendron -nc. All files downstream of.importexcept*.comments.mdshould be treated as read only.Upon import, notes and tags are left as stubs. To create these notes run> Dendron: DoctorthencreateMissingLinkedNotes. It is best practice to correct tag warnings before doing this. We warn on malformed tag imports. We could reform tags and sync to Zotero if there is interest.After running this command it is best to runDendron: Reload Indexfrom the command palette.zendron -horzendron --helpHelp message that shows availbe commands and suggsetions for when runningzendron.zendron -rmorzendron --remove⚠️ This command removes imported notes and associated links. This command works by removing all notes downstream todendron_limb. There is some difficulty removing other files created because these are separate from thedendron_limb. These files includeuser.*.md, which comes from bibtex keys, andtags.*.mdwhich come from metadata and annotation tags. For now, we don't remove tags, but we do remove bibex keys (<user.bibtex_key>.md).⚠️I have to say it again, don't put other notes downstream of the zendron limb. They will be deleted.We don't delete imported tags because they are too difficult to track consistently.zendron -drmorzendron --dry-removeA dry removal so you can see what file will be deleted without deleting them.zendron -ncorzendron --no-cacheThis is zendron sync without caching. This good to run if you interrupted your import for some reason and need a fresh clean import. If your zendron notes are misbehaving try this command. It will be slower since there is no caching.After running this command it is best to runDendron: Reload Indexfrom the command palette.Zotero and File Import ConfigurationAll zendron configuration is handled inconfig.yaml. Upon initialization it will show in"config/zendron/config.yaml".library_id : 4932032 # Zotero library ID
library_type : group # [user, group] library
api_key : FoCauOvWMlNdYmpYuY5JplTw # Zotero API key
collection: null # Name of Zotero Collection, null for entire library
local_image_path: /Users/<username>/Zotero/cache # Local path for importing annotated imagesdefault.yamlitem_types:[journalArticle,book,preprint,conferencePaper,report]# List of item types according to [pyzotero](https://pyzotero.readthedocs.io/en/latest/). Kept here for beginner simplicity.dendron_limb:zendron.import# Dendron import limb e.g. zendron.import.paper-title.annotations.md. KEEPING here for now since hasn't been tested.zotero_comment_title:zendron comment# needed for eventual 2-way sync. HERE for now.pod_path:zendron_pod# Name of dendron pod, removed after completion of import. Key for non dendron user import. Not implemented yet.library_id- Integer identifier of library. This is the number that matches the name of a library.User ID. For a user library it you will see something like"Your userID for use in API calls is 1234567"For group ID visitZotero Groups, click on your desired group, and copy the id from the URL. For instance I have this library."https://www.zotero.org/groups/4932032/zendron/library", and 4932032 is thelibrary_id.library_type:groupfor group libraries anduserfor user library.api_key: Use the API Key obtained fromZotero API KEY.collection: This can be the name of any collection or subcollection in the specificed library. If there are multiple collections or sub collections with the same name, the import will arbitrarily choose one. To make sure you are importing the desired collection, make sure the name of the collection is unique in the Zotero library. Subcollections of a collection will not be imported, this is by design according to how zotero handles subcollections and collections.item_types: Zotero item types to import according topyzoterosyntax.local_image_path: Path to annotated images./Users/<username>/Zotero/cacheis the default path on MacOS. It just needs to end incache.dendron_limb: This is the period deliminated hierarchy prefix to all file imports for Dendron, e.g.root.zotero.import.<paper_title>.annotations.md.pod_path- pod path for dendron import. Should not need to change. Will likely remove from configuration later so it doesn't get accidentally changed.zotero comment title- IGNORE FOR NOW. Eventually needed for 2-way sync.Import StructureWhen a paper is uploaded it will look something like this in your dendron graph.Comments notes are synced back to zotero after runningzendron. They are stored in a file calledzendron_commentsin the note data. After removing all data and runningzendronagain the comments created previously in a local workspace should be imported again. This allows for comments to be easily ported accross projects that reference the same papers.Comments notes are intended to be used for reference to any annotations under a Zotero item's metadata. This will preserve dendron linking with two-way sync.Supplementary importWe support import of supplementary pdfs if they have any of the following prefixes in their pdf title. This can be easily edited within Zotero. We can move this to configuration if custom naming is desired.["supp","Supp","supplementary","supp.","supplementary-material","supplementary-materials","sup","SI","si",]MiscellaneousThezendron_cacheis used for remove of<user.bibtex_key>.md. If it is deleted and you run remove, the<user.bibtex_key>.mdwill not be removed. In this case you can runzendronagain, then run thezendron remove=trueagain.If there are run that fail, sometimes a.hydrawith the given configuraiton will be generated in the root dir. This isn't an issue but it contains the API information and should therefore be added to the.gitignoreas a safeguard. In addition these files can be used to inspect the reason for the faiure.__main__.logis generated after running azendron, this can also be deleted as you please. It is also useful for inspecting an failures to import.Issues, Troubleshooting, Pull RequestsIf you are having trouble with startup you can use thisZendron-Testtemplate and try to reproduce your issues here. Simply click onUse this template, clone the repo and try to runzendronhere. This will allow for us to catch things we overlooked for different user workspace configuration etc. Once you have tried to reproduce issues here please submit an issue onZendronlinking to your minimal example.Common ErrorsA list of common errors and quick fixes to address them.Error - DendronError: vault with name your-vault-name not foundDendronError:vaultwithname<your-vault-name>notfoundFix - DendronError: vault with name your-vault-name not foundThis indicates that the vault name indendron.ymlwas not set.For example,workspace:vaults:-fsPath:.selfContained:truename:ZendronError - You see a Dendron Pod in your WorkspaceDendron PodA Dendron Pod is used for import according topod_pathin theconfig.yaml. This dir structure is normally deleted to allow for future importing. If you see it, something is wrong. Create an issue on GitHub, or delete the dir and retry the steps above.Fix - You see a Dendron Pod in your WorkspaceDelete the pod and rerun zendron to complete. If there is an additional error please report it. |
zenduty-airflow-operator | Airflow Plugin - ZendutyThis plugin creates a Zenduty Alert when plugin is run.OperatorsZendutyIncidentOperatorThis operator composes the logic for this plugin. It generates an Incident on Zenduty by sending an Alert to Zenduty.
It accepts the following parameters:api_key: API Key generated by Zenduty (Required).integration_id: The Integration_id generated by the API Integration (Required).title: Title of the incident that is to be created.summary: Summary for the incident to be created.RequirementsThis plugin requires thezenduty-apipython package.Example Failure Callback Usagefrom airflow.models import DAG, Variable
from airflow.operators.bash_operator import BashOperator
from zenduty_airflow_operator import ZendutyIncidentOperator
my_test_dag = DAG('example')
op = BashOperator(
dag=my_test_dag,
task_id='my_task',
provide_context=True,
python_callable=my_python_job,
on_failure_callback=zenduty_incident
)
def zenduty_incident():
operator = ZendutyIncidentOperator(
api_key=Variable.get("api_key"),
integration_id=Variable.get("integration_id"),
title="Test Title",
summary="Test Summary"
)
return operator.execute() |
zenduty-api | Python SDK wrapper for the Zenduty API |
zenefits-client | See GitHub |
zenefits-event-logger | Failed to fetch description. HTTP Status Code: 404 |
zen-engine | Python Rules EngineZEN Engine is a cross-platform, Open-Source Business Rules Engine (BRE). It is written inRustand provides native bindings forNodeJS,PythonandGo. ZEN Engine allows to load and executeJSON Decision Model (JDM)from JSON files.An open-source React editor is available on ourJDM Editorrepo.UsageZEN Engine is built as embeddable BRE for yourRust,NodeJS,PythonorGoapplications.
It parses JDM from JSON content. It is up to you to obtain the JSON content, e.g. from file system, database or service call.Installationpipinstallzen-engineUsageTo execute a simple decision you can use the code below.importzen# Example filesystem content, it is up to you how you obtain contentwithopen("./jdm_graph.json","r")asf:content=f.read()engine=zen.ZenEngine()decision=engine.create_decision(content)result=decision.evaluate({"input":15})LoadersFor more advanced use cases where you want to load multiple decisions and utilise graphs you can build loaders.importzendefloader(key):withopen("./jdm_directory/"+key,"r")asf:returnf.read()engine=zen.ZenEngine({"loader":loader})result=engine.evaluate("jdm_graph1.json",{"input":5})When engine.evaluate is invoked it will call loader and pass a key expecting a content of the JDM decision graph.
In the case above we will assume filejdm_directory/jdm_graph1.jsonexists.Similar to this example you can also utilise loader to load from different places, for example from REST API, from S3, Database, etc.Supported PlatformsList of platforms where Zen Engine is natively available:NodeJS-GitHub|Documentation|npmjsPython-GitHub|Documentation|pypiGo-GitHub|DocumentationRust (Core)-GitHub|Documentation|crates.ioFor a completeBusiness Rules Management Systems (BRMS)solution:Self-hosted BRMSGoRules Cloud BRMSJSON Decision Model (JDM)GoRules JDM (JSON Decision Model) is a modeling framework designed to streamline the representation and implementation of decision models.Understanding GoRules JDMAt its core, GoRules JDM revolves around the concept of decision models as interconnected graphs stored in JSON format.
These graphs capture the intricate relationships between various decision points, conditions, and outcomes in a GoRules Zen-Engine.Graphs are made by linking nodes with edges, which act like pathways for moving information from one node to another, usually from the left to the right.The Input node serves as an entry for all data relevant to the context, while the Output nodes produce the result of decision-making process. The progression of data follows a path from the Input Node to the Output Node, traversing all interconnected nodes in between. As the data flows through this network, it undergoes evaluation at each node, and connections determine where the data is passed along the graph.To see JDM Graph in action you can useFree Online Editorwith built in Simulator.There are 5 main node types in addition to a graph Input Node (Request) and Output Node (Response):Decision Table NodeSwitch NodeFunction NodeExpression NodeDecision NodeDecision Table NodeOverviewTables provide a structured representation of decision-making processes, allowing developers and business users to express complex rules in a clear and concise manner.StructureAt the core of the Decision Table is its schema, defining the structure with inputs and outputs. Inputs encompass business-friendly expressions using the ZEN Expression Language, accommodating a range of conditions such as equality, numeric comparisons, boolean values, date time functions, array functions and more. The schema's outputs dictate the form of results generated by the Decision Table.
Inputs and outputs are expressed through a user-friendly interface, often resembling a spreadsheet. This facilitates easy modification and addition of rules, enabling business users to contribute to decision logic without delving into intricate code.Evaluation ProcessDecision Tables are evaluated row by row, from top to bottom, adhering to a specified hit policy.
Single row is evaluated via Inputs columns, from left to right. Each input column representsANDoperator. If cell is empty that column is evaluatedtruthfully, independently of the value.If a single cell within a row fails (due to error, or otherwise), the row is skipped.HitPolicyThe hit policy determines the outcome calculation based on matching rules.The result of the evaluation is:an objectif the hit policy of the decision table isfirstand a rule matched. The structure is defined by the output fields. Qualified field names with a dot (.) inside lead to nested objects.null/undefinedif no rule matched infirsthit policyan array of objectsif the hit policy of the decision table iscollect(one array item for each matching rule) or empty array if no rules matchInputsIn the assessment of rules or rows, input columns embody theANDoperator. The values typically consist of (qualified) names, such ascustomer.countryorcustomer.age.There are two types of evaluation of inputs,UnaryandExpression.Unary EvaluationUnary evaluation is usually used when we would like to compare single fields from incoming context separately, for examplecustomer.countryandcart.total. It is activated when a column hasfielddefined in its schema.ExampleFor the input:{"customer":{"country":"US"},"cart":{"total":1500}}This evaluation translates toIF customer.country == 'US' AND cart.total > 1000 THEN {"fees": {"percent": 2}}
ELSE IF customer.country == 'US' THEN {"fees": {"flat": 30}}
ELSE IF customer.country == 'CA' OR customer.country == 'MX' THEN {"fees": {"flat": 50}}
ELSE {"fees": {"flat": 150}}List shows basic example of the unary tests in the Input Fields:Input entryInput Expression"A"the field equals "A""A", "B"the field is either "A" or "B"36the numeric value equals 36< 36a value less than 36> 36a value greater than 36[20..39]a value between 20 and 39 (inclusive)20,39a value either 20 or 39<20, >39a value either less than 20 or greater than 39truethe boolean value truefalsethe boolean value falseany value, even null/undefinednullthe value null or undefinedNote: For the full list please visitZEN Expression Language.Expression EvaluationExpression evaluation is used when we would like to create more complex evaluation logic inside single cell. It allows us to compare multiple fields from the incoming context inside same cell.It can be used by providing an emptySelector (field)inside column configuration.ExampleFor the input:{"transaction":{"country":"US","createdAt":"2023-11-20T19:00:25Z","amount":10000}}IF time(transaction.createdAt) > time("17:00:00") AND transaction.amount > 1000 THEN {"status": "reject"}
ELSE {"status": "approve"}Note: For the full list please visitZEN Expression Language.OutputsOutput columns serve as the blueprint for the data that the decision table will generate when the conditions are met during evaluation.When a row in the decision table satisfies its specified conditions, the output columns determine the nature and structure of the information that will be returned. Each output column represents a distinct field, and the collective set of these fields forms the output or result associated with the validated row. This mechanism allows decision tables to precisely define and control the data output.ExampleAnd the result would be:{"flatProperty":"A","output":{"nested":{"property":"B"},"property":36}}Switch Node (NEW)The Switch node in GoRules JDM introduces a dynamic branching mechanism to decision models, enabling the graph to diverge based on conditions.Conditions are written in a Zen Expression Language.By incorporating the Switch node, decision models become more flexible and context-aware. This capability is particularly valuable in scenarios where diverse decision logic is required based on varying inputs. The Switch node efficiently manages branching within the graph, enhancing the overall complexity and realism of decision models in GoRules JDM, making it a pivotal component for crafting intelligent and adaptive systems.The Switch node preserves the incoming data without modification; it forwards the entire context to the output branch(es).HitPolicyThere are two HitPolicy options for the switch node,firstandcollect.In the context of a first hit policy, the graph branches to the initial matching condition, analogous to the behavior observed in a table. Conversely, under a collect hit policy, the graph extends to all branches where conditions hold true, allowing branching to multiple paths.Note: If there are multiple edges from the same condition, there is no guaranteed order of execution.Available from:Python 0.16.0NodeJS 0.13.0Rust 0.16.0Go 0.1.0Functions NodeFunction nodes are JavaScript snippets that allow for quick and easy parsing, re-mapping or otherwise modifying the data using JavaScript. Inputs of the node are provided as function's arguments. Functions are executed on top of QuickJS Engine that is bundled into the ZEN Engine.Function timeout is set to a 50ms.consthandler=(input,{dayjs,Big})=>{return{...input,someField:'hello'};};There are two built in libraries:dayjs- for Date Manipulationbig.js- for arbitrary-precision decimal arithmetic.Expression NodeThe Expression node serves as a tool for transforming input objects into alternative objects using the Zen Expression Language. When specifying the output properties, each property requires a separate row. These rows are defined by two fields:Key - qualified name of the output propertyValue - value expressed through the Zen Expression LanguageNote: Any errors within the Expression node will bring the graph to a halt.Decision NodeThe "Decision" node is designed to extend the capabilities of decision models. Its function is to invoke and reuse other decision models during execution.By incorporating the "Decision" node, developers can modularize decision logic, promoting reusability and maintainability in complex systems.Support matrixArchRustNodeJSPythonGolinux-x64-gnu:heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark:linux-arm64-gnu:heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark:darwin-x64:heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark:darwin-arm64:heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark:win32-x64-msvc:heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark:We do not support linux-musl currently.ContributionJDM standard is growing and we need to keep tight control over its development and roadmap as there are number of
companies that are using GoRules Zen-Engine and GoRules BRMS.
For this reason we can't accept any code contributions at this moment, apart from help with documentation and additional
tests. |
zenetka | Failed to fetch description. HTTP Status Code: 404 |
zenfeed | Zen feed reader − inspired by zencancan.Documentation is available at <http://fspot.github.io/zenfeed/>.ScreenshotsFeed list :Feed view :Article view :Layout on smartphones :Todoadd import/export OPML featuretest zenfeed with mysql and postgresqlactually remove oldest entries when threshold is exceeded |
zen-fillet | Util to calculate fillet or chamfer radius by reducing or reducing by radius |
zenfilter | Info:This is the README file for zenfilter.Author:Shlomi Fish <[email protected]>Copyright:© 2016, Shlomi Fish.Date:2021-09-01Version:0.6.5PURPOSEThis small script filters long STDIN output, performing several functions
to keep track of the important parts and progresses, which will be hard to
do with a shell script.It is useful for filtering the output of verbose
Travis-CI (https://travis-ci.org/) commands, but may be useful in other
contexts where there is a limit to the amount of kept output.All arguments are optional:–count-step=n: displaysCOUNT <tab> <step>every n lines.–last=n: displays the last n lines prefixed with “LASTt”–filter=<regex pattern>: displays matching lines with a “FOUNDt” prefix.–suppress-last-on=<regex>: suppress the last lines if their concatenated output matches the regex.Examples:python zenfilter.py --count-step=10 --last=200 --filter="[0-9]+"
python zenfilter.py --last=20
python zenfilter.py --last=25 --count-step=15A use case scenario:make 2>&1 | python zenfilter.py [args]COPYRIGHTCopyright © 2016, Shlomi Fish.
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:Redistributions of source code must retain the above copyright
notice, this list of conditions, and the following disclaimer.Redistributions in binary form must reproduce the above copyright
notice, this list of conditions, and the following disclaimer in the
documentation and/or other materials provided with the distribution.Neither the name of the author of this software nor the names of
contributors to this software may be used to endorse or promote
products derived from this software without specific prior written
consent.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
“AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
zenfin | # Zen Financial Tools |
zenframe | ZenFrameAbstract part of the graphical interface of the ZenCad project.ZenFrame is a sandbox that controls the execution of python scripts with graphical output. ZenFrame implements the process control, inter process communication, settings storing etc. |
zengapay | ZengaPay API Python ClientPower your apps with our ZengaPay APIThis is the ZENGAPAY Python Client LibraryUsageInstallationAdd the latest version of the library to your project by using pip:$ pip install zengapayThis library supports Python 3.6+Sandbox and Production EnvironmentCreating a sandbox environment user environmentBefore using the library in your applications, please head over to theAPI Documentationto see how to set up your sandbox environment.The following is the API Endpoint for our sandbox environment:https://api.sandbox.zengapay.com/v1Here is the API Endpoint for our production environment:https://api.zengapay.com/v1ConfigurationBefore we can fully utilize the library, we need to specify the global configurations. The global configuration must contain the following.ZENGAPAY_APP_SETTINGS: Optional environment, either "sandbox" or "production". Default is "sandbox".ZENGAPAY_BASE_URL: An optional base url to ZengaPay API. By default the sandbox base url will be used.ZENGAPAY_USER_API_TOKEN: Your secret user API token. This is mandatory. See heAPI Documentationto obtain your API token.Once you have specified the global config variables, the full configuration object to use in your project should look like this.config={ZENGAPAY_ENVIRONMENT:os.environ.get("ZENGAPAY_APP_SETTINGS","sandbox"),ZENGAPAY_BASE_URL:os.environ.get("ZENGAPAY_BASE_URL","https://api.sandbox.zengapay.com/v1"),ZENGAPAY_USER_API_TOKEN:os.environ.get("ZENGAPAY_USER_API_TOKEN")}This will be need for each transaction you will be performing.Collections.The collections client can be created with configuration parameters as indicated above.importosfromzengapayimportCollectionsconfig={ZENGAPAY_ENVIRONMENT:os.environ.get("ZENGAPAY_APP_SETTINGS","sandbox"),ZENGAPAY_BASE_URL:os.environ.get("ZENGAPAY_BASE_URL","https://api.sandbox.zengapay.com/v1"),ZENGAPAY_USER_API_TOKEN:os.environ.get("ZENGAPAY_USER_API_TOKEN")}client=Collections(config)Methodscollect: This operation is used to request a payment from another consumer(Payer). The payer will be asked to authorize the payment. The transaction is executed once the payer has authorized the payment. The transaction will be in status PENDING until it is authorized or declined by the payer or it is timed out by the system. Status of the transaction can be validated by usingget_collection(transaction_ref)orget_transaction_status(transaction_ref)using thetransaction reference.You can perform a collection using the payload as below. See heAPI Documentationto get what the parameters mean.payload={"msisdn":"256703######",# The phone number that the collection request is intended for."amount":20000,#The collection request amount."external_reference":"157899393020236",# Internal description or reason for this collection request and must be unique for every request."narration":"Clearing Invoice - #157899393020236"# Textual narrative describing the transaction.}collection=client.collect(payload)get_collections: Retrieve the collection transactions for a given account.collections=client.get_collections()get_collection: Retrieve a certain collection transaction using thetransaction referencecollection=client.get_collection(transaction_ref)get_transaction_status: The status of the transaction, this can be one of these;PENDING,SUCCEEDED,FAILED,INDETERMINATEtrans_status=client.get_transaction_status(transaction_ref)Transfers.The transfers client can be created with configuration parameters as indicated above.importosfromzengapayimportTransfersconfig={ZENGAPAY_ENVIRONMENT:os.environ.get("ZENGAPAY_APP_SETTINGS","sandbox"),ZENGAPAY_BASE_URL:os.environ.get("ZENGAPAY_BASE_URL","https://api.sandbox.zengapay.com/v1"),ZENGAPAY_USER_API_TOKEN:os.environ.get("ZENGAPAY_USER_API_TOKEN")}client=Transfers(config)Methodstransfer: Used to transfer an amount from the owner’s account to a payee account. Status of the transaction can be validated by usingget_transfer(transaction_ref)orget_transaction_status(transaction_ref)using thetransaction reference.You can perform a transfer using the payload as below. See heAPI Documentationto get what the parameters mean.payload={"msisdn":"256703######",# The phone number that the transfer request is intended for."amount":20000,#The transfer request amount."external_reference":"157899393020236",# Internal description or reason for this transfer request and must be unique for every request."narration":"Clearing Invoice - #157899393020236"# Textual narrative describing the transaction.}transfer=client.transfer(payload)get_transfers: Retrieve the transfer transactions for a given account.transfers=client.get_transfers()get_transfer: Retrieve a certain tranfer transaction using thetransaction referencetransfer=client.get_transfer(transaction_ref)get_transaction_status: The status of the transaction, this can be one of these;PENDING,SUCCEEDED,FAILED,INDETERMINATEtrans_status=client.get_transaction_status(transaction_ref)AccountThe account client can be created with configuration parameters as indicated above.importosfromzengapayimportAccountsconfig={ZENGAPAY_ENVIRONMENT:os.environ.get("ZENGAPAY_APP_SETTINGS","sandbox"),ZENGAPAY_BASE_URL:os.environ.get("ZENGAPAY_BASE_URL","https://api.sandbox.zengapay.com/v1"),ZENGAPAY_USER_API_TOKEN:os.environ.get("ZENGAPAY_USER_API_TOKEN")}client=Accounts(config)See theAPI Documentation.Methodsget_balance: This API allows you to get the current merchant account balance.balance=client.get_balance()get_account_statement: To retrieve a list of all transactions on your account (account statement). This will return a list of transactions. SeeAPI Documentationto see how to make filters.statement=client.get_account_statement()Performing a limit and status filters. See link above for more filtersstatement=client.get_account_statement(limit=2,status='FAILED') |
zengge | No description available on PyPI. |
zenggewifi | Python control for Zengge Wi-Fi LED bulbsExample usageConnectingimportzenggewifibulb=zenggewifi.ZenggeWifiBulb('192.168.1.20')bulb.connect()Get Statestate=bulb.get_status()Returns a status object which contains of these members:state.deviceType# Type of devicestate.isOn# whether device is onstate.Mode# current modestate.Slowness# current slownessstate.Color# current color, color objectstate.LedVersionNum# version of LEDSet Colorbulb.set_on(color)Color object has these members:self.R# Red value [0-255]self.G# Green value [0-255]self.B# Blue value [0-255]self.W# Warmwhite value [0-255]self.IgnoreW# Whether warmwhite is ignored (then RGB is used) or not (then only warmwhite is used)Turn offbulb.set_off() |
zengin-code | The python implementation of ZenginCode.ZenginCode is datasets of bank codes and branch codes for japanese.Installationpipinstallzengin_codeUsagefromzengin_codeimportBankBank.all# => OrderedDict([(u'0001', <zengin_code.bank.Bank object at 0x1044173d0>), ...ContributingBug reports and pull requests are welcome on GitHub athttps://github.com/zengin-code/zengin-pyLicenseThe package is available as open source under the terms of theMIT License. |
zengine | No description available on PyPI. |
zen-git | Github Zen utility toolsThis is a simple project aimed at improving command-line developer workflow with git. |
zengl | ZenGLpip install zenglDocumentationzengl on Githubzengl on PyPIConceptZenGL is a low level graphics library.ZenGL turns OpenGL into Vulkan likeRendering PipelinesZenGL usesOpenGL 3.3 CoreandOpenGL 3.0 ES- runs everywhereZenGL provides a developer friendly experience in protyping complex scenesZenGL emerged from an experimental version ofModernGL.
To keep ModernGL backward compatible, ZenGL was re-designed from the ground-up to support a strict subset of OpenGL.
On the other hand, ModernGL supports a wide variety of OpenGL versions and extensions.ZenGL is "ModernGL hard mode"ZenGL intentionally does not support:Transform FeedbackGeometry ShadersTesselationCompute Shaders3D TexturesStorage BuffersMost of the above can be implemented in a more hardware friendly way using the existing ZenGL API.
Interoperability with other modules is also possible. Using such may reduce the application's portablity.
It is even possible to use direct OpenGL calls together with ZenGL, however this is likely not necessary.It is common to render directly to the screen with OpenGL.
With ZenGL, the right way is to render to a framebuffer and blit the final image to the screen.
This allows fine-grained control of the framebuffer format, guaranteed multisampling settings, correct depth/stencil precison.
It is also possible to render directly to the screen, however this feature is designed to be used for the postprocessing step.This design allows ZenGL to support:Rendering without a windowRendering to multiple windowsRendering to HDR monitorsRefreshing the screen without re-rendering the sceneApply post-processing without changing how the scene is renderedMaking reusable shaders and componentsTaking screenshots or exporting a videoThedefault framebufferin OpenGL is highly dependent on how the Window is created.
It is often necessary to configure the Window to provide the proper depth precision, stencil buffer, multisampling and double buffering.
Often the "best pixel format" lacks all of these features on purpose. ZenGL aims to allow choosing these pixel formats and ensures the user specifies the rendering requirements.
It is even possible to render low-resolution images and upscale them for high-resolution monitors.
Tearing can be easily prevented by decoupling the scene rendering from the screen updates.ZenGL was designed for PrototypingIt is tempting to start a project with Vulkan, however even getting a simple scene rendered requires tremendous work and advanced tooling to compile shaders ahead of time. ZenGL provides self-contained Pipelines which can be easily ported to Vulkan.
ZenGL code is verbose and easy to read.ZenGL support multiple design pattersMany libraries enfore certain design patterns.
ZenGL avoids this by providing cached pipeline creation, pipeline templating and lean resourece and framebuffer definition.
It is supported to create pipelines on the fly or template them for certain use-cases.TODO: examples for such pattersDisambiguationZenGL is a drop-in replacement for pure OpenGL codeUsing ZenGL requires some OpenGL knowledgeZenGL Images are OpenGLTexture Objectsor OpenGLRenderbuffer ObjectsZenGL Buffers are OpenGLBuffer ObjectsZenGL Pipelines contain an OpenGLVertex Array Object, an OpenGLProgram Object, and an OpenGLFramebuffer ObjectZenGL Pielines may also contain OpenGLSampler ObjectsCreating ZenGL Pipelines does not necessarily compile the shader from sourceThe ZenGL Shader Cache exists independently from the Pipeline objectsA Framebuffer is always represented by a Python list of ZenGL ImagesThere is noPipeline.clear()method, individual images must be cleared independentlyGLSL Uniform Blocks and sampler2D objects are bound in the Pipeline layoutTextures and Uniform Buffers are bound in the Pipeline resourcesExamplesSimple Pipeline Definitionpipeline=ctx.pipeline(# program definitionvertex_shader='...',fragment_shader='...',layout=[{'name':'Uniforms','binding':0,},{'name':'Texture','binding':0,},],# descriptor setsresources=[{'type':'uniform_buffer','binding':0,'buffer':uniform_buffer,},{'type':'sampler','binding':0,'image':texture,},],# uniformsuniforms={'color':[0.0,0.5,1.0],'iterations':10,},# program definition global statedepth={'func':'less','write':False,},stencil={'front':{'fail_op':'replace','pass_op':'replace','depth_fail_op':'replace','compare_op':'always','compare_mask':1,'write_mask':1,'reference':1,},'back':...,# or'both':...,},blend={'enable':True,'src_color':'src_alpha','dst_color':'one_minus_src_alpha',},cull_face='back',topology='triangles',# framebufferframebuffer=[color1,color2,...,depth],viewport=(x,y,width,height),# vertex arrayvertex_buffers=[*zengl.bind(vertex_buffer,'3f 3f',0,1),# bound vertex attributes*zengl.bind(None,'2f',2),# unused vertex attribute],index_buffer=index_buffer,# or Noneshort_index=False,# 2 or 4 byte intexvertex_count=...,instance_count=1,first_vertex=0,# override includesincludes={'common':'...',},)# some members are actually mutable and calls no OpenGL functionspipeline.viewport=...pipeline.vertex_count=...pipeline.uniforms['iterations'][:]=struct.pack('i',50)# writable memoryview# renderingpipeline.render()# no parameters for hot code |
zengl-export | zengl-export |
zengl-extras | No description available on PyPI. |
zen-grip | Grip shape builder for ZenCAD |
zenguard | ZenGuard Python ClientZenGuard Python Client to adopt GenAI with peace of mind. |
zenhan | No description available on PyPI. |
zen-han-converter | zen_han_converterDescriptionThis is a tool for converting full-width and half-width characters to each other, implemented only with Python's standard modules.Target charactersLatin alphabetArabic numeralsASCII symbolsSpaceInstallactionpip install zen_han_converterUsage>>> from zen_han_converter import ZenToHan
>>> zen_to_han = ZenToHan()
>>> zen_to_han.convert('ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ')
'abcdefghijklmnopqrstuvwxyz' |
zenhest | No description available on PyPI. |
zenimport | No description available on PyPI. |
zen-involute | Involute gear profile builder for ZenCAD |
zenipy | No description available on PyPI. |
zenircbot_api | This is in dev currently.Once it is released you’ll be able to do the following:$ pip install zenircbot_apiAnd you’ll be able to use it like so:from zenircbot_api import ZenIRCBot
client = ZenIRCBot(hostname='redis.server.location', port=6379)
client.send_privmsg(to='#channel', message='ohai')Docs are availabe at:http://zenircbot.rtfd.org/History2.2.6 (2014-02-28)Use atexit to make sure gevent greenlets die.2.2.5 (2014-02-26)Fix pubsub parser to check for proper message type.2.2.4 (2012-06-28)added services command2.2.3 (2012-04-17)removed extra ‘ in library2.2.2 (2012-04-17)Switched to gevent instead of Thread to make killing services easier.2.2.1 (2012-04-17)Add symlink for LICENSE so it includes properly when making the package.2.2.0 (2012-04-17)Add MANIFEST.inVersion bump to match major/minor step with ZenIRCBot.2.1.3 (2012-04-11)Creating history |
zenith | zenithPython LibraryChange Log0.0.1 (07/11/2020)-First Release
-Added overlap_grid function. |
zenithta | ZenithTAFormerly PantherA efficient, high-performance python technical analysis library written in Rust using PyO3 and rust-numpy.IndicatorsATRCMFSMAEMARSIMACDROCHow to build (Windows)Runcargo build --releasefrom the main directory.Get the generated dll from the target/release directory.Rename extension from .dll to .pyd.Place .pyd file in the same folder as script.Putfrom panther import *in python script.SpeedOn average, I found the Panther calculations of these indicators to be about 9x or 900% faster than the industry standard way of calculating these indicators using Pandas. Don't believe me? Install the library and run the tests in the speed_tests directory to see it for yourself :)LicenseMIT LicenseCopyright (c) 2022 Greg JamesPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. |
zenity-py | zenity-py - Zenity for PythonExactly what it says it is.How to installJust typepython3 -m pip install zenity-pyand it should install just fine.BUT, you need to also check if Zenity is installed.
Type in the Command Prompt/Terminal:zenity.
If this is the output you get:You must specify a dialog type. See 'zenity --help' for detailsthen you're good to go and you can get to using zenity-py.If it says something likezsh: command not found: zenityor'zenity' is not recognized as an internal or external command, operable program or batch file., then you don't have it installed.How to install Zenity - Linux/MacOn Linux, use your system's package manager or Homebrew to install it.
Example:sudo apt install zenityOn Mac, use Homebrew to install it.
Example:brew install zenityHow to install Zenity - WindowsInstall MinGW then search for Zenity in it. I don't use Windows anymore and I never really used MinGW for any other stuff other then make, so that's all i'm saying.How to useIn a python file, typefromzenityimportZenity# Zenity syntax - title, body, type, options[]# the ! in !timeout means it is an option, not a valuez=Zenity("Title","Body","info",["!timeout",5])This should create a new Zenity instance. Of course, this is an example, so you can change anything.
After that, addz.Open()This should start up Zenity with the parameters you specified.
If a zenity window doesn't appear, something went wrong.
You can always print() the z variable, as the Zenity class returns both the status code and output.If you want to know what arguments you can use, go over to theZenity Manual.
Do not add an option like !calendar or !password onto the options. Just change the type to "calendar" or "password". |
zenius | zeniusWrapper/API for zenius simfile downloads |
zenkai | ZenkaiZenkai is a framework built on Pytorch for researchers to more easily explore a wider variety of machine architectures for deep learning (or just learning with hidden layers). It is fundamentally based on the concepts of target propagation, where a target is propagated backward. As backpropagation with gradient descent can be viewed as a form of target propagation, it extends what one can do with Pytorch to a much larger class of machines. It aims to allow for much more freedom and control over the learning process while minimizing the added complexity.InstallationpipinstallzenkaiBrief OverviewZenkai consists of several packages to more flexibly define and train deep learning machines beyond what is easy to do with Pytorch.zenkai: The core package. It contains all modules necessary for defining a learning machine.zenkai.utils: Utils contains a variety of utility functions that are . For example, utilities for ensemble learning and getting retrieving model parameters.zenkai.kikai: Kikai contains different types of learning machines : Hill Climbing, Scikit-learn wrappers, Gradient based machines, etc.zenkai.tansaku: Package for adding more exploration to learning. Contains framework for defining and creating population-based optimizers.Further documentation is available athttps://zenkai.readthedocs.ioUsageZenkai's primary feature is the "LearningMachine" which aims to make defining learning machines flexible. The design is similar to Torch, in that there is a forward method, a parameter update method similar to accGradParameters(), and a backpropagation method similar to updateGradInputs(). So the primary usage will be to implement them.Here is a (non-working) exampleclassMyLearner(zenkai.LearningMachine):"""A LearningMachine couples the learning mechanics for the machine with its internal mechanics."""def__init__(self,module:nn.Module,step_theta:zenkai.StepTheta,step_x:StepX,loss:zenkai.Loss):super().__init__()self.module=module# step_theta is used to update the parameters of the# moduleself._step_theta=step_theta# step_x is used to update the inputs to the moduleself._step_x=step_xself.loss=lossdefassess_y(self,y:IO,t:IO,reduction_override:str=None)->zenkai.AssessmentDict:# assess_y evaluates the output of the learning machinereturnself.loss.assess_dict(x,t,reduction_override)defstep(self,x:IO,t:IO,state:State):# use to update the parameters of the machine# x (IO): The input to update with# t (IO): the target to update# outputs for a connection of two machinesreturnself._step_theta(x,t,state)defstep_x(self,x:IO,t:IO,state:State)->IO:# use to update the target for the machine# step_x is analogous to updateGradInputs in Torch except# it calculates "new targets" for the incoming layerreturnself._step_x(x,t,state)defforward(self,x:zenkai.IO,state:State,release:bool=False)->zenkai.IO:y=self.module(x.f)returny.out(release=release)my_learner=MyLearner(...)forx,tindataloader:state=State()assessment=my_learner.learn(x,t,state=state)# outputs the logs stored by the learnerprint(state.logs)Learning machines can be stacked by making use of step_x in the training process.classMyMultilayerLearner(LearningMachine):"""A LearningMachine couples the learning mechanics for the machine with its internal mechanics."""def__init__(self,layer1:LearningMachine,layer2:LearningMachine):super().__init__()self.layer1=layer1self.layer2=layer2# use these hooks to indicate a dependency on another methodself.add_step(StepXDep(self,'t1',use_x=True))self.add_step_x(ForwardDep(self,'y1',use_x=True))defassess_y(self,y:IO,t:IO,reduction_override:str=None)->zenkai.AssessmentDict:# assess_y evaluates the output of the learning machinereturnself.layer2.assess_y(y,t)defstep(self,x:IO,t:IO,state:State):# use to update the parameters of the machine# x (IO): The input to update with# t (IO): the target to update# outputs for a connection of two machinesmy_state=state.mine((self,x))self.layer2.step(my_state['y2'],my_state['t1'])self.layer1.step(my_state['y1'],t1)defstep_x(self,x:IO,t:IO,state:State)->IO:# use to update the target for the machine# it calculates "new targets" for the incoming layermy_state=state.mine((self,x))t1=my_state['t1']=self.layer2.step_x(my_state['y2'],t)returnself.layer1.step_x(my_state['y1'],t1)defforward(self,x:zenkai.IO,state:State,release:bool=True)->zenkai.IO:# define the state to be for the self, input pairmy_state=state.mine((self,x))x=my_state['y1']=self.layer1(x,state)x=my_state['y2']=self.layer2(x,state,release=release)returnxmy_learner=MyLearner(...)forx,tindataloader:state=State()assessment=my_learner.learn(x,t,state=state)# outputs the logs stored by the learnerprint(state.logs)ContributingTo contribute to the projectFork the projectCreate your feature branchCommit your changesPush to the branchOpen a pull requestLicenseThis project is licensed under the MIT License - see the LICENSE.md file for details.Citing this SoftwareIf you use this software in your research, we request you cite it. We have provided aCITATION.cfffile in the root of the repository. Here is an example of how you might use it in BibTeX: |
zenkat | ZenKatZenKat is a tool and library to enable using a set of plaintext files, especially markdown files, as aZettelkastenknowledge base.I've used a number of knowledge management tools including Obsidian, Notion, and Coda, and have found them all lacking and / or designed in a way that makes them act as a walled garden. ZenKat is an attempt to create a lightweight FOSS alternative for command-line users. As such it aims to have few dependencies while still providing decent features.It's named this way because of my bad memory for German. I remembered ZEttelKAsTen as ZenKat (unclear where the N came from).Recommended SetupYou can install directly from pip:pip install zenkatThis also installs thezenkatconvenience script.To configure themes and create custom queries and formats, make a file at~/.config/zenkat/config.toml.If you'd like to run directly from source you can clone the repository and usedevelopment mode.It's also worth installingMarksman LSPif you plan on working with plaintext files a lot. This should work with major CLI editors including Helix, Neovim, and Spacemacs, as well as KATE. I use Helix.For viewing files as formatted you can useMD Fileserverwithmdstart.diffcomes by default on the command line and can be extremely helpful when combining duplicate notes (which Obsidian's multiple vaults tend to lead to).FeaturesFilter and sort through notes with powerful mapping syntaxCustomisable output formats and color schemesSupports markdown tags, and unpacks nested tagsResolves internal links, both inbound and outboundLoads YAML metadata headers in pagesTask tracking with beautiful formatting, filters, and extended syntaxConfiguration usingconfig.tomlin your home folder: seedefault_configfor optionsContentsUsageFields and SubfieldsFormattingFiltersSortingTasksgrep and catQueriesMacros |
zenkit | No description available on PyPI. |
zenkly | zenklyA CLI for Zendesk administation tasks.Installationpip3 install zenklyNote: Zenkly is currently only compatible with Python3.Usagetodo |
zen-knit | About Zen-Knit:Zen-Knit is a formal (PDF), informal (HTML) report generator for data analyst and data scientist who wants to use python. RMarkdown alternative.
Zen-Knit is good for creating reports, tutorials with embedded python. RMarkdown alternative. Python Markdown Support. It also allows you to publish reports to analytics-reports.zenreportz.com (comming soon) or private zenreportz serversVS Code Plugin:Download VS Plugin fromMarketPlaceFeatures:.py and .pyz file supportPython 3.7+ compatibilitySupport for IPython magics and rich output.Execute python codein the chunks andcaptureinput and output to a report.Use hidden code chunks,i.e. code is executed, but not printed in the output file.Capture matplotlib graphics.Evaluate inline code in documentation chunks marked using{ }Publish reports from Python scripts. Similar to R markdown.Interactive Plots using plotlyintegrate it in your process. It will fit your need rather than you need to adjust for tool.custom CSS support (HTTP(s) and local file)direct sql supportchaching executed code for faster report devlopementprinting index of chunk or chunk name in consoleExamples:All example are availableHEREPDF examplePDF example with SQLHTML exampleHTML example with custom CSSHTML example with SQLInstallFrom PyPi:pip install --upgrade zen-knitor download the source and run::python setup.py installOther Dependencyinstall pandoc from :https://github.com/jgm/pandoc/releasesinstall texlive for debian: sudo apt install texlive-fullinstall texlive for window:https://www.tug.org/texlive/acquire-netinstall.htmlinstall texlive for mac:https://tug.org/texlive/quickinstall.htmlLicense informationPermission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.How to Use itpip install zen-knitknit -f doc/example/html_example.pyz -ofd doc/example/output/knit -f doc/example/pdf_example.pyz -ofd doc/example/output/python doc/example/demo.pyArguments---
title: Zen Markdown Demo
author: Dr. P. B. Patel
date: CURRENT_DATE
output:
cache: true
format: html
html:
css: skleton
---Above code will map on GlobalOption class in in followingclass Input(BaseModel):
dir: Optional[str]
file_name: Optional[str]
matplot: bool = True
class latexOuput(BaseModel):
header: Optional[str]
page_size: Optional[str] = 'a4paper'
geometry_parameter: Optional[str] = "text={16.5cm,25.2cm},centering" #Newely added parameters
class htmlOutput(BaseModel):
css: str = "bootstrap"
class Output(BaseModel):
fig_dir: str = "figures"
format: Optional[str]
file_name: Optional[str]
dir: Optional[str]
latex: Optional[latexOuput]
html: Optional[htmlOutput]
class GlobalOption(BaseModel):
title: str
author: Optional[str]
date: Optional[str]
kernal: str = "python3"
log_level: str = "debug"
cache: Optional[bool] = False
output: Output
input: Input
@validator('log_level')
def fix_option_for_log(cls, v:str):
if v.lower() not in ('notset', "debug", 'info', 'warning', 'error', 'critical'):
raise ValueError('must contain a space')
return v.title()Zen Publish:Ability to publish programmable, formal, informal reports to Private or Public instance of zen reportz.
Learn more atHereLearn more about how to publish to private or public instance of Zen ReportzHereanalytics-reports.zenreportz.com featuresStatic Reports like HTML, PDFAny one access reportsFree to useUnlimite PublishRepublish report same place again |
zenkPytone | # pytone |
zenlabs-ml-framework | Zenlabs Machine Learning Framework |
zenlayercloud-sdk-python | Zenlayer Cloud Python SDK is the official software development kit, which allows Python developers to write software that makes use of Zenlayer Cloud services like BMC and VM.The SDK works on Python versions:2.7 and greater, including 3.xQuick StartFirst, install the library:$pipinstallzenlayercloud-sdk-pythonor download source code from github and install:$gitclonehttps://github.com/zenlayer/zenlayercloud-sdk-python.git$cdzenlayercloud-sdk-python$pythonsetup.pyinstall |
zen_lib | 个人整合工具代码，包含线程池、简单Tkinter界面、文件读取筛选等功能 |
zenlib-desultory | Failed to fetch description. HTTP Status Code: 404 |
zenlog | UNKNOWN |
zenlogger | No description available on PyPI. |
zen-logging | Zen Logging@loggifyThis decorator can be added to any class to initialize it with a logger, and add extra logging functionality to that class.The following additional kwargs are handled ininit:logger(Logger) Used as the parent logger, if not set, uses the root logger._log_init(bool) Can be passed to loggified classes, to enable or disable additional initialization logging._log_bump(int) Changes the log level for added loggers.Loggified classes will also log use of __getattribute__, __setattr__, and __getitem__.Functions returned from __getattribute__ will automatically log additioanl information such as passed args and results.ColorLognameFormatterAlogging.Formatterwhich colors the loglevel portion. |
zenlux | #LuxA microframework for personal ease of use |
zenmai | toylang on yaml or jsoncommand line examplemain.yamlcode:$import:./filters.pyas:fdefinitions:$let:nums:{$load:./nums.yaml#/definitions/nums0/enum}odds:type:integerenum:$f.odds:{$get:nums}even:type:integerenum:$f.evens:{$get:nums}nums.yamldefinitions:nums0:type:integerenum:[1,2,3,4,5,6]nums1:type:integerenum:[1,2,3,5,7,11]filters.pydefodds(nums):return[nforninnumsifn%2==1]defevens(nums):return[nforninnumsifn%2==0]run.$zenmaiexamples/readme2/main.yamloutputzenmai main.yamldefinitions:odds:type:integerenum:-1-3-5even:type:integerenum:-2-4-6config loaderusing zenmai as config loader.fromzenma.loaderimportloadwithopen("config.yaml")asrf:d=load(rf)0.3.0$concat improvementtiny error reporting improvementchanging $load’s scope0.2.3fix loader bug0.2.2fix–databug0.2.1raw format0.2.0add$inheritactionzenmai as config loader0.1.0:first release |
zenmake | ZenMake is a cross-platform build system for C/C++ and some other languages.Main featuresBuild config as python (.py) or as yaml file.Distribution as zip application or as system package (pip).Automatic reconfiguring: no need to run command ‘configure’.Compiler autodetection.Building and running functional/unit tests including an ability to
build and run tests only on changes.Build configs in sub directories.Building external dependencies.Supported platforms: GNU/Linux, MacOS, MS Windows. Some other
platforms like OpenBSD/FreeBSD should work as well but it
hasn’t been tested.Supported languages:C: gcc, clang, msvc, icc, xlc, suncc, irixccC++: g++, clang++, msvc, icpc, xlc++, sunc++D: dmd, ldc2, gdc; MS Windows is not supported yetFortran: gfortran, ifort (should work but not tested)Assembler: gas (GNU Assembler)Supported toolkits/frameworks: SDL2, GTK3, Qt5DocumentationFor full documentation, including installation, tutorials and PDF documents,
please seehttps://zenmake.readthedocs.ioProject linksPrimary git repository:https://github.com/pustotnik/zenmakeSecondary git repository:https://gitlab.com/pustotnik/zenmakeIssue tracker:https://github.com/pustotnik/zenmake/issuesPypi package:https://pypi.org/project/zenmakeDocumentation:https://zenmake.readthedocs.io |
zen-mapper | Zen MapperPerfection is achieved, not when there is nothing more to add, but when there
is nothing left to take away.Antoine de Saint-ExupéryZen mapper is a minimal implementation of the TDA algorithm MapperInstallationThere are two supported methods of installationPyPiZen Mapper has a distribution onPyPi.
You can install it using pip:pipinstallzen-mapperNixZen Mapper is also packaged as a nix flake. If you have nix installed and flake
support enabled. You can create a dev environment with Zen Mapper installed
easily enough:nixflakenew-tgithub:zen-mapper/zen-mappernew_projectcdnew_project
nixdevelopWill drop you into a shell with python 3.11 and Zen Mapper configured. |
zen-markup-lang | IntroductionZen Markup Language is a markup language designed to store application configs. It combines the advantages of JSON, XML and YAML.ZML can store any JSON object.ZML keeps high readlibility even with deep nested structure like XML.ZML has a XML-like syntax, but is as user-frendly as YAML.ZML doesn't rely on indentation like JSON and XML.InstallationJust run this command.pip install zen-markup-langQuick StartSyntaxThe syntax of ZML is very intuitive. The follwing example demostrates basic ZML syntax.<!zml 0.1><a>114514</a><b>1919.810</b><c>true</c><d>false</d><e>null</e><f><>"hello`t"</><>"world!"</></f><g>empty_obj</g><h><i>empty_arr</i></h>The ZML file above is equivalent to the following JSON object:{"a":114514,"b":1919.810,"c":true,"d":false,"e":null,"f":["hello\t","world!"],"g":{},"h":{"i":[]}}A major difference is that the escaping character in ZML is ` instead of common \ .Use ZML in PythonThe package is namedzen_markup_lang. You can import the package likeimportzen_markup_langaszmlThere are four functions in the package,load,loads,dumpanddumps. They are similar to the functions in Python standard libraryjson.withopen('a.zml')asf:d=zml.load(f)print(zml.dumps(d))That's all. Enjoy! 👏 |
zen-matematika-yanwarsolah | Example PackageThis is a simple example package. You can useGithub-flavored Markdownto write your content. |
zen-mechanizm | Util to display and export to STL group of objects in ZenCAD |
zenml | Build portable, production-ready MLOps pipelines.Join ourSlack Communityand be part of the ZenML family.Features·Roadmap·Report Bug·Vote New Features·Read Blog·Contribute to Open Source·Meet the Team🎉 Version 0.55.3 is out. Check out the release noteshere.🏁 Table of ContentsIntroductionQuickstartCreate your own MLOps PlatformDeploy ZenMLDeploy Stack ComponentsCreate a PipelineStart the DashboardRoadmapContributing and CommunityGetting HelpLicense🤖 Introduction🤹 ZenML is an extensible, open-source MLOps framework for creating portable,
production-ready machine learning pipelines. By decoupling infrastructure from
code, ZenML enables developers across your organization to collaborate more
effectively as they develop to production.💼 ZenML gives data scientists the freedom to fully focus on modeling and
experimentation while writing code that is production-ready from the get-go.👨💻 ZenML empowers ML engineers to take ownership of the entire ML lifecycle
end-to-end. Adopting ZenML means fewer handover points and more visibility on
what is happening in your organization.🛫 ZenML enables MLOps infrastructure experts to define, deploy, and manage
sophisticated production environments that are easy to use for colleagues.ZenML provides a user-friendly syntax designed for ML workflows, compatible with
any cloud or tool. It enables centralized pipeline management, enabling
developers to write code once and effortlessly deploy it to various
infrastructures.🤸 QuickstartInstall ZenMLviaPyPI. Python 3.8 - 3.11 is required:pipinstall"zenml[server]"Take a tour with the guided quickstart by running:zenmlgo🖼️ Create your own MLOps PlatformZenML allows you to create and manage your own MLOps platform using
best-in-class open-source and cloud-based technologies. Here is an example of
how you could set this up for your team:🔋 1. Deploy ZenMLFor full functionality ZenML should be deployed on the cloud to
enable collaborative features as the central MLOps interface for teams.Currently, there are two main options to deploy ZenML:ZenML Cloud: WithZenML Cloud,
you can utilize a control plane to create ZenML servers, also known as tenants.
These tenants are managed and maintained by ZenML's dedicated team, alleviating
the burden of server management from your end.Self-hosted deployment: Alternatively, you have the flexibility todeploy
ZenML on your own self-hosted environment.
This can be achieved through various methods, including using our CLI, Docker,
Helm, or HuggingFace Spaces.👨🍳 2. Deploy Stack ComponentsZenML boasts a ton ofintegrationsinto
popular MLOps tools. TheZenML Stackconcept ensures that these tools work nicely together, therefore bringing
structure and standardization into the MLOps workflow.Deploying and configuring this is super easy with ZenML. ForAWS, this might
look a bit like this# Deploy and register an orchestrator and an artifact storezenmlorchestratordeploykubernetes_orchestrator--flavorkubernetes--cloudaws
zenmlartifact-storedeploys3_artifact_store--flavors3# Register this combination of components as a stackzenmlstackregisterproduction_stack--orchestratorkubernetes_orchestrator--artifact-stores3_artifact_store--set# Register your production environmentWhen you run a pipeline with this stack set, it will be running on your deployed
Kubernetes cluster.You can alsodeploy your own tooling manually.🏇 3. Create a PipelineHere's an example of a hello world ZenML pipeline in code:# run.pyfromzenmlimportpipeline,step@stepdefstep_1()->str:"""Returns the `world` substring."""return"world"@stepdefstep_2(input_one:str,input_two:str)->None:"""Combines the two strings at its input and prints them."""combined_str=input_one+' '+input_twoprint(combined_str)@pipelinedefmy_pipeline():output_step_one=step_1()step_2(input_one="hello",input_two=output_step_one)if__name__=="__main__":my_pipeline()pythonrun.py👭 4. Start the DashboardOpen up the ZenML dashboard using this command.zenmlshow🗺 RoadmapZenML is being built in public. Theroadmapis a
regularly updated source of truth for the ZenML community to understand where
the product is going in the short, medium, and long term.ZenML is managed by acore teamof
developers that are responsible for making key decisions and incorporating
feedback from the community. The team oversees feedback via various channels,
and you can directly influence the roadmap as follows:Vote on your most wanted feature on ourDiscussion
board.Start a thread in ourSlack channel.Create an issueon our
GitHub repo.🙌 Contributing and CommunityWe would love to develop ZenML together with our community! The best way to get
started is to select any issue from thegood-first-issuelabeland open up a Pull Request! If you
would like to contribute, please review ourContributing
Guidefor all relevant details.🆘 Getting HelpThe first point of call should
beour Slack group.
Ask your questions about bugs or specific use cases, and someone from
thecore teamwill respond.
Or, if you
prefer,open an issueon
our GitHub repo.Vulnerability affectingzenml<0.67(CVE-2024-25723)We have identified a critical security vulnerability in ZenML versions prior to
0.46.7. This vulnerability potentially allows unauthorized users to take
ownership of ZenML accounts through the user activation feature. Pleaseread our
blog postfor more information on how we've addressed this.📜 LicenseZenML is distributed under the terms of the Apache License Version 2.0.
A complete version of the license is available in theLICENSEfile in
this repository. Any contribution made to this project will be licensed under
the Apache License Version 2.0. |
zen-ml | No description available on PyPI. |
zenml-nightly | Build portable, production-ready MLOps pipelines.Join ourSlack Communityand be part of the ZenML family.Features·Roadmap·Report Bug·Vote New Features·Read Blog·Contribute to Open Source·Meet the Team🎉 Version 0.55.0 is out. Check out the release noteshere.🏁 Table of ContentsIntroductionQuickstartCreate your own MLOps PlatformDeploy ZenMLDeploy Stack ComponentsCreate a PipelineStart the DashboardRoadmapContributing and CommunityGetting HelpLicense🤖 Introduction🤹 ZenML is an extensible, open-source MLOps framework for creating portable,
production-ready machine learning pipelines. By decoupling infrastructure from
code, ZenML enables developers across your organization to collaborate more
effectively as they develop to production.💼 ZenML gives data scientists the freedom to fully focus on modeling and
experimentation while writing code that is production-ready from the get-go.👨💻 ZenML empowers ML engineers to take ownership of the entire ML lifecycle
end-to-end. Adopting ZenML means fewer handover points and more visibility on
what is happening in your organization.🛫 ZenML enables MLOps infrastructure experts to define, deploy, and manage
sophisticated production environments that are easy to use for colleagues.ZenML provides a user-friendly syntax designed for ML workflows, compatible with
any cloud or tool. It enables centralized pipeline management, enabling
developers to write code once and effortlessly deploy it to various
infrastructures.🤸 QuickstartInstall ZenMLviaPyPI. Python 3.8 - 3.11 is required:pipinstall"zenml[server]"Take a tour with the guided quickstart by running:zenmlgo🖼️ Create your own MLOps PlatformZenML allows you to create and manage your own MLOps platform using
best-in-class open-source and cloud-based technologies. Here is an example of
how you could set this up for your team:🔋 1. Deploy ZenMLFor full functionality ZenML should be deployed on the cloud to
enable collaborative features as the central MLOps interface for teams.Currently, there are two main options to deploy ZenML:ZenML Cloud: WithZenML Cloud,
you can utilize a control plane to create ZenML servers, also known as tenants.
These tenants are managed and maintained by ZenML's dedicated team, alleviating
the burden of server management from your end.Self-hosted deployment: Alternatively, you have the flexibility todeploy
ZenML on your own self-hosted environment.
This can be achieved through various methods, including using our CLI, Docker,
Helm, or HuggingFace Spaces.👨🍳 2. Deploy Stack ComponentsZenML boasts a ton ofintegrationsinto
popular MLOps tools. TheZenML Stackconcept ensures that these tools work nicely together, therefore bringing
structure and standardization into the MLOps workflow.Deploying and configuring this is super easy with ZenML. ForAWS, this might
look a bit like this# Deploy and register an orchestrator and an artifact storezenmlorchestratordeploykubernetes_orchestrator--flavorkubernetes--cloudaws
zenmlartifact-storedeploys3_artifact_store--flavors3# Register this combination of components as a stackzenmlstackregisterproduction_stack--orchestratorkubernetes_orchestrator--artifact-stores3_artifact_store--set# Register your production environmentWhen you run a pipeline with this stack set, it will be running on your deployed
Kubernetes cluster.You can alsodeploy your own tooling manually.🏇 3. Create a PipelineHere's an example of a hello world ZenML pipeline in code:# run.pyfromzenmlimportpipeline,step@stepdefstep_1()->str:"""Returns the `world` substring."""return"world"@stepdefstep_2(input_one:str,input_two:str)->None:"""Combines the two strings at its input and prints them."""combined_str=input_one+' '+input_twoprint(combined_str)@pipelinedefmy_pipeline():output_step_one=step_1()step_2(input_one="hello",input_two=output_step_one)if__name__=="__main__":my_pipeline()pythonrun.py👭 4. Start the DashboardOpen up the ZenML dashboard using this command.zenmlshow🗺 RoadmapZenML is being built in public. Theroadmapis a
regularly updated source of truth for the ZenML community to understand where
the product is going in the short, medium, and long term.ZenML is managed by acore teamof
developers that are responsible for making key decisions and incorporating
feedback from the community. The team oversees feedback via various channels,
and you can directly influence the roadmap as follows:Vote on your most wanted feature on ourDiscussion
board.Start a thread in ourSlack channel.Create an issueon our
GitHub repo.🙌 Contributing and CommunityWe would love to develop ZenML together with our community! The best way to get
started is to select any issue from thegood-first-issuelabeland open up a Pull Request! If you
would like to contribute, please review ourContributing
Guidefor all relevant details.🆘 Getting HelpThe first point of call should
beour Slack group.
Ask your questions about bugs or specific use cases, and someone from
thecore teamwill respond.
Or, if you
prefer,open an issueon
our GitHub repo.📜 LicenseZenML is distributed under the terms of the Apache License Version 2.0.
A complete version of the license is available in theLICENSEfile in
this repository. Any contribution made to this project will be licensed under
the Apache License Version 2.0. |
zen-models | No description available on PyPI. |
zenmoney | Python library for ZenMoney APIThis library allows you to useZenMoney API.There is a simplest way to start:fromzenmoneyimport*oauth=OAuth2('consumer_key','consumer_secret','user_name','user_pass')api=Request(oauth.token)diff=api.diff(Diff(**{'serverTimestamp':1})) |
zenner-nester | No description available on PyPI. |
zen_nester | UNKNOWN |
zennews | 📜 ZenNews: Generate summarized news on a scheduleIn today's information age, we are bombarded with a constant stream of news
and media from a variety of sources. Summarizing tasks, particularly when it
comes to news sources, can be a powerful tool for the efficient consumption of
information. They distill complex or lengthy content into easily
digestible chunks that can be scanned and absorbed quickly, allowing us to
keep up with the news without being overwhelmed. They can also help us separate
the signal from the noise, highlighting the most important details and helping
us identify what's worth further investigation.This is whereZenNewscome into play. It offers a tool that can
automate the summarization process and save users time and effort while
providing them with the information they need. This can be particularly valuable
for busy professionals or anyone who wants to keep up with the news but doesn't
have the time to read every article in full.🎯 The goal of the projectThe definition of the concrete use case aside, this project aims to showcase
some of the advantages that ZenML brings to the table. Some major points we
would like to highlight include:The ease of use: ZenML featuresa simple and clean Python
SDK. As you can
observe in this example, it is not only used to define your steps and
pipelines but also to access/manage the resources and artifacts that you
interact with along the way. This makes it significantly easier for you
to build their applications around ZenML.The extensibility: ZenML is an extensible framework. ML projects often
require custom-tailored solutions and what you get out of the box may not be
what you need. This is why ZenML is using base abstractions to allow you
to create your own solutions without reinventing the whole wheel. You can find
great examples of this feature by taking a look at the custom materializer
(ArticleMaterializer)
and the custom stack component
(DiscordAlerter)
implemented within the context of this project.Stack vs Code: One of the main features of ZenML is rooted within the
concept of our stacks. As you follow this example, you will see that there is a
complete separation between the code and the infrastructure that the pipeline
is running on. In fact, by utilizing just one flag, it is possible to switch
from a local default stack to a remote deployment with scheduled pipelines.The scalability: This is a small PoC-like example that aims to prove
that ZenML can help you streamline your workflows and accelerate your
development process. However, it barely scratches the surface of how you can
improve it even further. For more information, checkthis section.🐍 Base installationTheZenNewsproject is designed as aPyPI packagethat you can install throughpip:pipinstallzennewsThe package comes equipped with the following set ofkeypieces:The pipeline: Thezen_news_pipelineis the main pipeline in this workflow. In total, it features three steps,
namelycollect,summarizeandreport. The first step is responsible
for collecting articles, the second step summarizes them, and the last step
creates a report and posts it.The steps: There is a concrete implementation for each step defined above.For thecollectstep, we have thebbc_news_sourcewhich (by default) collects the top stories from the BBC news feed and
preparesArticleobjects.For thesummarizestep, we have implementedbart_large_cnn_samsumstep. As the name suggests, it uses the BART model to generate summaries.Ultimately, for thereportstep, we have implemented thepost_summariesstep. It showcases how a generalized step can function within a ZenML
pipeline and uses an alerter to share the results.The materializer: As mentioned above, the steps within our pipeline are
using the concept ofArticles to define their input and output space. Using
theArticleMaterializer,
we can show how to handle the materialization of these artifacts
when it comes to a data type that is not built-in.The custom stack component: The ultimate goal ofZenNewsis to
serve the use the direct outcomes of the pipeline. That is why we have used it
as a chance to show the extensibility of ZenML in terms of the stack components
and implemented aDiscordAlerter.The CLI application: The example also includes aClickCLI application.
It utilizes how easily you can use our Python SDK to build your application
around your ZenML workflows. In order to see it in action simply execute:zennews--help🕹 Test it locally right awayAfter installing thezennewspackage, you are ready to test it out locally
right away. The following command will get the top five articles from the BBC
news feed, summarize them and present the results to you.Warning: This will temporarily switch your active ZenML stack to thedefaultstack and when the pipeline runs, you will download the model
to your local machine.zennewsbbcYou can also parameterize this process. In order to see the possible
parameters, please use:zennewsbbc--help🚀 Switching to scheduled pipelines with VertexThe potential of an application likezennewscan be only unlocked by
scheduling summarization pipelines instead of manually triggering them
yourself. In order to showcase it, we will set up a fully remote GCP stack
and use theVertexOrchestratorto schedule the pipeline.Deploy ZenML on GCPBefore you start building the stack, you need to deploy ZenML on GCP. For more
information on how you can achieve do that, please checkthe corresponding docs page.ZenNews StackOnce the ZenML is deployed, we can start to build up our stack. Our stack will
consist of the following components:GCP Secrets ManagerGCP Container RegistryGCS Artifact StoreVertex OrchestratorDiscord Alerter (part of thezennewspackage)Let's start by installing thegcpintegration:zenmlintegrationinstallgcpSecrets ManagerThe first component to register is aGCP secrets manager.
The command is quite straightforward. You just have to give it a name and
provide the ID of your project on GCP.zenmlsecrets-managerregister<SECRETS_MANAGER_NAME>\--flavor=gcp\--project_id=<PROJECT_ID>Container RegistryThe second component is aGCP container registry.
Similar to the previous component, you just need to provide a name and the
URI to your container registry on GCP.zenmlcontainer-registryregister<CONTAINER_REGISTERY_NAME>\--flavor=gcp\--uri=<REGISTRY_URI>Artifact StoreThe next component on the list is aGCS artifact store.
In order to register it, all you have to do is to provide the path to your GCS
bucket:zenmlartifact-storeregister<ARTIFACT_STORE_NAME>\--flavor=gcp\--path=<PATH_TO_BUCKET>OrchestratorFollowing the artifact store, we will register aVertex AI orchestrator.zenmlorchestratorregister<ORCHESTRATOR_NAME>\--flavor=vertex\--project=<PROJECT_ID>\--location=<GCP_LOCATION>\--workload_service_account=<EMAIL_OF_YOUR_SERVICE_ACCOUNT>\--service_account_path=<PATH_TO_YOUR_SERVICE_ACCOUNT_KEY>You need to simply provide the id of your project, the name of your GCP
region and the service account you would like to use.Warning: In this version, you have to provide both the email of the service
account and the path to a key.json file. This interaction will be improved
in the upcoming releases.Make sure that the service account has the proper roles for the following
services: Cloud Functions, Cloud Scheduler, Secret Manager, Service Account,
Storage, and Vertex AI.GCP StackWith these four components, we are ready to establish and activate the base
version of our GCP stack.zenmlstackregister<STACK_NAME>\-x<SECRETS_MANAGER_NAME>\-c<CONTAINER_REGISTERY_NAME>\-a<ARTIFACT_STORE_NAME>\-o<ORCHESTRATOR_NAME>\--setAlerterThe last component in our stack is a special case. As mentioned before
thezennewspackage already comes equipped with a custom stack component
implementation, namely theDiscordAlerter. In a nutshell, it uses thediscord.pypackage
to send messages via a webhook to a discord text channel. You can find the
implementation righthere.The following sections show how we can registerDiscordAlerteras a custom
flavor, create an instance of it, and update our stack.Registering the custom flavorAll you have to do to register such a custom flavor is to provide the
corresponding source path to the flavor class.zenmlalerterflavorregisterzennews.alerter.discord_alerter_flavor.DiscordAlerterFlavorZenML will import and add that to the list of available alerter flavors.zenmlalerterflavorlistRegistering the alerterNow that the flavor is registered, you can create an alerter with the flavordiscord-webhook. Through this example, you will also see how you can use
secret references to handle sensitive information during the registration of
stack components.Let's start by registering the secret:zenmlsecrets-managersecretregister<SECRET_NAME>\--webhook_url=<ACTUAL_URL_OF_THE_WEBHOOK>This will use the secrets manager in our active GCP stack. Once the secret
registration is complete, you can register your alerter as follows:zenmlalerterregister<ALERTER_NAME>\--flavordiscord-webhook\--webhook_url=<SECRET_REFERENCE># formatted as {{SECRET_NAME:WEBHOOK_URL}}Updating the stackThe last step is to update our stack with our new alerter:zenmlstackupdate<STACK_NAME>-al<ALERTER_NAME>Scheduling pipelines through thezennewsCLINow the stack is set up, you can use the--scheduleoption when you run yourzennewspipeline. There are three possible values that you can use for thescheduleoption:hourly,daily(every day at 9 AM), orweekly(every
Monday at 9 AM).zennewsbbc--scheduledailyThis will use your active stack (the GCP stack) and schedule your ZenNews
pipeline.📙 Limitations, future improvements and upcoming changesBefore we end this project, it is also important to talk about the limitations
we faced, the possible future improvements, and changes that are already in
motion:The first limitation of ZenNews is the number of supported news sources.
As this project was initially designed as a PoC, the only supported news
source is BBC. However, thanks to our design, it is really easy to expand this
list by adding additional steps, which consume data and createArticleobjects.The ability to schedule pipelines through ZenML played a critical role
within the context of this project. However, this feature has its own
limitations. While you can create scheduled pipelines, once the pipeline and
its schedule is created, you can not cancel or modify the behavior of this
scheduled pipeline. This means that if you want to cancel it, you have to do it
via the orchestrator UI or interface yourself and not from within ZenML.The other limitation regarding the schedules is the format. As of now, the
CLI application takes the user input and converts it into a cron expression.
Any orchestrator which does not support these expressions is not supported.As the ZenML team, we have been looking for ways to improve the interface
of our base alerters. You might see some changes in upcoming releases.Similar to the alerters, we are working on improving the management of our
secrets.Tune in toour slackto stay updated about
the upcoming changes and ask any questions you might have. |
zennit | ZennitZennit (Zennitexplainsneuralnetworksintorch) is a
high-level framework in Python using Pytorch for explaining/exploring neural
networks. Its design philosophy is intended to provide high customizability and
integration as a standardized solution for applying rule-based attribution
methods in research, with a strong focus on Layerwise Relevance Propagation
(LRP). Zennit strictly requires models to use Pytorch'storch.nn.Modulestructure (including activation functions).Zennit is currently under active development, but should be mostly stable.If you find Zennit useful for your research, please consider citing our relatedpaper:@article{anders2021software,
author = {Anders, Christopher J. and
Neumann, David and
Samek, Wojciech and
Müller, Klaus-Robert and
Lapuschkin, Sebastian},
title = {Software for Dataset-wide XAI: From Local Explanations to Global Insights with {Zennit}, {CoRelAy}, and {ViRelAy}},
journal = {CoRR},
volume = {abs/2106.13200},
year = {2021},
}DocumentationThe latest documentation is hosted atzennit.readthedocs.io.InstallTo install directly from PyPI using pip, use:$pipinstallzennitAlternatively, install from a manually cloned repository to try out the examples:$gitclonehttps://github.com/chr5tphr/zennit.git
$pipinstall./zennitUsageAt its heart, Zennit registers hooks at Pytorch's Module level, to modify the
backward pass to produce rule-based attributions like LRP (instead of the usual
gradient). All rules are implemented as hooks
(zennit/rules.py) and most use the LRP basisBasicHook(zennit/core.py).Composites(zennit/composites.py) are a way
of choosing the right hook for the right layer. In addition to the abstractNameMapComposite, which assigns hooks to layers by name, andLayerMapComposite, which assigns hooks to layers based on their Type, there
exist explicitComposites, some of which areEpsilonGammaBox(ZBoxin
input,Epsilonin dense,Gammain convolutions) orEpsilonPlus(Epsilonin dense,ZPlusin convolutions). All composites may be used by directly
importing fromzennit.composites, or by using their snake-case name as key
forzennit.composites.COMPOSITES.Canonizers(zennit/canonizers.py) temporarily
transform models into a canonical form, if required, likeSequentialMergeBatchNorm, which automatically detects and merges BatchNorm
layers followed by linear layers in sequential networks, orAttributeCanonizer, which temporarily overwrites attributes of applicable
modules, e.g. to handle the residual connection in ResNet-Bottleneck modules.Attributors(zennit/attribution.py) directly
execute the necessary steps to apply certain attribution methods, like the
simpleGradient,SmoothGradorOcclusion. An optionalCompositemay
be passed, which will be applied during theAttributor's execution to
compute the modified gradient, or hybrid methods.Using all of these components, an LRP-type attribution for VGG16 with
batch-norm layers with respect to label 0 may be computed using:importtorchfromtorchvision.modelsimportvgg16_bnfromzennit.compositesimportEpsilonGammaBoxfromzennit.canonizersimportSequentialMergeBatchNormfromzennit.attributionimportGradientdata=torch.randn(1,3,224,224)model=vgg16_bn()canonizers=[SequentialMergeBatchNorm()]composite=EpsilonGammaBox(low=-3.,high=3.,canonizers=canonizers)withGradient(model=model,composite=composite)asattributor:out,relevance=attributor(data,torch.eye(1000)[[0]])A similar setup usingthe example scriptproduces the following attribution heatmaps:For more details and examples, have a look at ourdocumentation.More Example HeatmapsMore heatmaps of various attribution methods for VGG16 and ResNet50, all
generated usingshare/example/feed_forward.py, can be found
below.Heatmaps for VGG16Heatmaps for ResNet50ContributingSeeCONTRIBUTING.mdfor detailed instructions on how to contribute.LicenseZennit is licensed under the GNU LESSER GENERAL PUBLIC LICENSE VERSION 3 OR
LATER -- see theLICENSE,COPYINGandCOPYING.LESSERfiles for details. |
zennit-crp | An open-source library for neural network interpretability built onzennitwith Relevance and Activation Maximization.Concept Relevance Propagation (CRP)computes conditional attributions for in latent space defined concepts that allow tolocalize concepts in input spacecompute their relative importance to the final classification outputand hierarchically decompose higher-level concepts into low-level conceptsIn addition, this repository ships withRelevance Maximizationan explaining-by-example strategy for concepts that illustrates the mostusefulpattern for prediction, unlikeActivation Maximization, which reveals patterns that lead tostrong activation.Activation Maximizationas reference sampling approach and class-wide statistics are also supplied for comparision.Curious? Then take a look at ourpreprint:@article{achtibat2022from,
title = {From "Where" to "What": Towards Human-Understandable Explanations through Concept Relevance Propagation},
author = {Achtibat, Reduan and
Dreyer, Maximilian and
Eisenbraun, Ilona and
Bosse, Sebastian and
Wiegand, Thomas and
Samek, Wojciech and
Lapuschkin, Sebastian},
journal={arXiv},
year = {2022},
volume={abs/2206.03208},
doi = {10.48550/ARXIV.2206.03208},
url = {https://arxiv.org/abs/2206.03208},
}Why Concept Relevance Propagation?For a detailed discussion, feel free to check out the paper, but here we will give a summary of the most exciting features:OverviewCRP applied on three age range predictions given different input samples from the Adience dataset
for age and gender estimation.(Left):Traditional heatmaps are rather
uninformative despite being class-specific.
Here, heatmaps only hint at the locations of relevant body parts, but what feature(s) in particular the model has recognized in those regions remains open for interpretation by the stakeholder, which, depending on the domain, may prove to be highly ambiguous. In this case, they indicate that the model seems to focus on the eye region during inference in all cases.(Rightmost):Intermediate features encoded by the model in general
can be investigated using global XAI (Activation or Relevance Maximization). Choosing a particular layer, individual channels can be
assigned concepts. However, during
inference, global XAI alone does not inform which features are recognized, used and combined
by the model in per-sample inference.(Center):By combining local and global XAI,glocalXAI is able to assign (relevance) attribution scores to individual neuron(-group)s. This tells, which concepts have been involved in a particular prediction. Further, concept-conditional heatmaps can be computed, indicating where a recognized concept identified as relevant has its origin in a sample’s input space. Vice versa, choosing a specific region in input space, the local relevance attribution, responsible concepts can be traced
back. Lastly, peripheral information can be masked out of the shown reference examples using
conditionally computed heatmap attributions for further focusing the feature visualization on the
concept’s defining parts, which increases interpretability and clarity:Concentrating on the eye region, we immediately recognize that the topmost sample has been predicted into age group (3-7)
due to the sample’s large irides and round eyes, while the middle sample is predicted as (25-32), as
more of the sclera is visible and eyebrows are more ostensible. For the bottom sample the model
has predicted class (60+) based on its recognition of heavy wrinkles around the eyes and on the
eyelids, and pronounced tear sacs next to a large knobby nose.Disentangling ExplanationsTarget concept “dog” is described by a combination of lower-level concepts such as “snout”, “eye” and “fur”. CRP heatmaps regarding individual concepts, and their contribution to the prediction of “dog”, can be generated by applying masks to filter-channels in the backward pass. Global (in the context of an input sample) relevance of a concept wrt. to the explained prediction can thus not only be measured in latent space, but also precisely visualized, localized and measured in input space. The concept-conditional computation reveals the relatively high importance of the spatially distributed “fur” feature for the prediction of “dog”, compared to the feature “eye”.Localization of ConceptsCRP applied in combination with local aggregation of relevance scores over regions $I_1$ and $I_2$ in order to locally assess conceptual importance and localize concepts involved in inference.Relevance vs. Activation MaximizationActivation- and relevance-based sample selection.a)Activation scores only measure
the stimulation of a latent filter without considering its role and impact during inference. Relevance scores are contextual to distinct model outputs and describe how features
are utilized in a DNN’s prediction of a specific class.b)As a result, samples selected
based on Activation Maximization only represent maximized latent neuron activation, while
samples based on Relevance Maximization represent features which are actually useful and
representative for solving a prediction task.(A) ActMax identifies a concept that encodes for white strokes. RelMax, however, shows that this concept is not simply used to find white strokes, but white characters!c)Assume we wish to find representative examples for features $x_1$
and $x_2$. Even though a sample leads to a high activation score in a given layer and neuron (group) — here $x_1$ and $x_2$ — it does not necessarily result in high relevance or contribution to inference: The feature transformation $w$ of a linear layer with inputs $x_1$ and $x_2$, which is followed by a ReLU non-linearity, is shown. Here, samples from the blue cluster of feature activations lead to high activation values for both features $x_1$ and $x_2$, and would be selected by ActMax, but receive zero relevance, as they lead to an inactive neuron output after the ReLU, and are thus of no value to following layers. That is, even though
the given samples activate features $x_1$ and $x_2$ maximally strong, they can not contribute
meaningfully to the prediction process through the context determined by $w$. Thus, samples
selected as representative via activation might not be representative to the overall decision
process of the model. Representative examples selected based on relevance, however, are
guaranteed to play an important role in the model’s decision process.d):Correlation analyses are shown for an intermediate ResNet layer’s channel and neuron. Neurons that are on average highly activated are not, in general, also highly relevant, as a correlation coefficient of $c = 0.111$ shows, since a specific combination of activation magnitudes is important for neurons to be representative in a larger model context.Hierarchical Concept Decomposition through Attribution GraphsDecomposing a high-level concept into its lower-level concepts.Given an interesting concept encoded by channel j in layer l, relevance quantities computed during a CRP backward pass can then be utilized to identify how its relevance distributes across lower layer channels (here shown side-by-side in an exploded view).Project statusProject is under active development but should be stable. Please expect interfaces to change in future releases.InstallationTo install directly from PyPI using pip, write:$pipinstallzennit-crp[fast_img]Alternatively, install from a manually cloned repository to try out the tutorials:$gitclonehttps://github.com/rachtibat/zennit-crp
$pipinstall./zennit-crpDocumentationStill under development, but you can refer to the tutorials below.
Docstrings are also missing in some places.TutorialsCheck out thejupyter notebook tutorials.Please start with attribution and then feature_visualization.QuickstartConditional Attributionsfromcrp.attributionimportCondAttributionfromcrp.conceptsimportChannelConceptfromcrp.helperimportget_layer_namesfromzennit.compositesimportEpsilonPlusFlatfromzennit.canonizersimportSequentialMergeBatchNorm# define LRP rules and canonizers in zennitcomposite=EpsilonPlusFlat([SequentialMergeBatchNorm()])# load CRP toolboxattribution=CondAttribution(model)# here, each channel is defined as a concept# or define your own notion!cc=ChannelConcept()# get layer names of Conv2D and MLP layerslayer_names=get_layer_names(model,[nn.Conv2d,nn.Linear])# get a conditional attribution for channel 50 in layer features.27 wrt. output 1conditions=[{'features.27':[50],'y':[1]}]attr=attribution(data,conditions,composite,record_layer=layer_names)# heatmap and predictionattr.heatmap,attr.prediction# activations and relevances for each layer nameattr.activations,attr.relevances# relative importance of each concept for final predictionrel_c=cc.attribute(attr.relevances['features.40'])# most relevant channels in features.40concept_ids=torch.argsort(rel_c,descending=True)Feature Visualizationfromcrp.visualizationimportFeatureVisualizationfromcrp.imageimportplot_grid# define which concept is used in each layerlayer_map={(name,cc)fornameinlayer_names}# compute visualization (it takes for VGG16 and ImageNet testset on Titan RTX 30 min)fv=FeatureVisualization(attribution,dataset,layer_map)fv.run(composite,0,len(dataset))# visualize MaxRelevance reference images for top-5 conceptsref_c=fv.get_max_reference(concept_ids[:5],'features.40','relevance',composite=composite)plot_grid(ref_c)RoadmapComing soon...Distributed HPC-Cluster supportComplete MaskHook TutorialVisualization for the Attribution GraphDocumentationContributingCode StyleWe usePEP8with a line-width of 120 characters. For
docstrings we usenumpydoc.We usepylintfor style checks.Basic tests are implemented withpytest.We are open to any improvements (:LicenseBSD 3-Clause Clear License |
zennla | UNKNOWN |
zeno | ZenoZeno's Paradoxes Illustrated in PythonResourceshttps://en.wikipedia.org/wiki/Zeno%27s_paradoxesUsagepip install zenoExecutables are prefixed withze-# The Dichotomy
ze-dichotomyDevelopmentIn addition to following the setup guidehttps://packaging.python.org/tutorials/packaging-projects/I added a minimalsetup.pyso thatpip install -e .would workSeeMakefilefor build and upload optionsInstall package fromtest.pypi.org(uploaded withmake test_upload)pip install --index-url https://test.pypi.org/simple/ --no-deps zeno |
zenoai | Zeno Python ClientThis is a simple Python client for Zeno. |
zeno-build | Zeno BuildZeno Buildis a tool for developers who want to quickly build, compare, and
iterate on applications using large language models.It provides:Simple examplesof code to build LLM-based apps. The examples are
architecture agnostic, we don't care if you are usingOpenAI,LangChain, orHugging
Face.Experiment managementandhyperparameter optimizationcode, so you can
quickly kick off experiments using a bunch of different settings and compare
the results.Evaluationof LLM outputs, so you can check if your outputs are correct,
fluent, factual, interesting, or "good" by whatever definition of good you
prefer! Use these insights to compare models and iteratively improve your
application with model, data, or prompt engineering.Sound interesting? Read on!Getting StartedTo get started withzeno-build, install the package from PyPI:pipinstallzeno-buildNext,start building! Browse to thedocsdirectory to get a
primer or to theexamples/directory, where we
have a bunch of examples of how you can usezeno-buildfor different tasks,
such aschatbots,text summarization, ortext
classification.Each of the examples include code for running experiments and evaluating the
results.zeno-buildwill produce a comprehensive report with theZenoAI evaluation platform.Interactive Demos/ReportsUsing Zeno Build, we have generated reports and online browsing demos of
state-of-the-art systems for different popular generative AI tasks.
Check out our pre-made reports below:Chatbots(Report,Browser):
A report comparing different methods
for creating chatbots, including API-based models such as ChatGPT and Cohere,
with open-source models such as Vicuna, Alpaca, and MPT.Translation(Report,Browser):
A report comparing GPT-based methods, Microsoft Translator, and the best system
from the Conference on Machine Translation.Building Your Own Apps (and Contributing Back)Each of the examples in theexamples/directory is specifically designed
to be self-contained and easy to modify. To get started building your own apps,
we suggest that you first click into the directory and read the general README,
find the closest example to what you're trying to do, copy the example to the
new directory, and start hacking!If you build something cool,we'd love for you to contribute it back. We
welcome pull requests of both new examples, new reports for existing examples,
and new functionality for the corezeno_buildlibrary. If this is of interest
to you, please click through to ourcontributing docdoc to
learn more.CITATIONTo citeGPT-MT report, please use the
following BibTeX/APA entry.BibTeX@misc{Neubig_Zeno_GPT_Machine_2023,author={Neubig, Graham andHe, Zhiwei},title={{Zeno GPT Machine Translation Report}},year={2023}}APANeubig, G., & He, Z. (2023). Zeno GPT Machine Translation ReportGet in TouchIf you have any questions, feature requests, bug reports, etc., we recommend
getting in touch via the githubissues
pageordiscord, where the community can discuss and/or
implement your suggestions! |
zeno-client | Zeno Python ClientThe Zeno Python client lets you create and manage Zeno projects from Python.Check out example projects athub.zenoml.com,learn how to use the API, orsee the full API documentation.Release InstructionsTo create a new release, first send a PR with a bumped package version inpyproject.toml.Then, in GitHub, click on "Releases" and "Draft a new Release".
From here click on "tag" and create a new tag of the formvX.X.Xfor your new version.
Make the release title the same as the tag.
Click "Generate release notes", and publish the release.
GitHub will start an action to push the new package to PyPI |
zenodio | zenodio — I/O with ZenodoPython library for uploading research artifacts toZenodowith their REST API and downloading artifacts from community collections with their OAI-PMH Datacite v3 harvest API.In development.LicenseCopyright 2015 AURA/LSSTMIT license. |
zeno-distributions | No description available on PyPI. |
zenodo | Zenodo, a CERN service, is an open dependable home for the long-tail of
science, enabling researchers to share and preserve any research outputs in
any size, any format and from any science.Powered by InvenioZenodo is a small layer on top ofInvenio <http://github.com/inveniosoftware/invenio>, a free software
suite enabling you to run your own digital library or document repository on
the web.InstallationSee INSTALL.rstDeveloper documentationSeehttp://zenodo.readthedocs.orgLicenseCopyright (C) 2009-2015 CERN.Zenodo is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.Zenodo is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.You should have received a copy of the GNU General Public License
along with Zenodo; if not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
MA 02111-1307, USA.In applying this license, CERN does not
waive the privileges and immunities granted to it by virtue of its status
as an Intergovernmental Organization or submit itself to any jurisdiction.ChangesVersion 2.0.0 (released TBD)Major refactoring to move from Invenio 2.x to 3.x. |
zenodo-accessrequests | Zenodo module for providing access request feature.This is an experimental developer preview release.Free software: GPLv2 licenseDocumentation:https://pythonhosted.org/zenodo-accessrequests/ChangesVersion 1.0.0a5 (released April 9th, 2019)Initial public release. |
zenodo-api-client | No description available on PyPI. |
zenodo-backpack | zenodo_backpackZenodoBackpack provides a robust, standardised and repeatable approach to
distributing and using backend databases that bioinformatic tools rely on. These
databases are usually tool-specific and are often large enough in size that they
cannot be uploaded as data to software repositories (e.g. PyPI imposes a limit
of ~50MB).ZenodoBackpack uploads/downloads data to/fromZenodo,
which means that each dataset is associated with a DOI. Additionally, it
encapsulates the uploaded data in a Zenodo Backpack format, which is really just
aCONTENTS.jsonfile and compresses the data in.tar.gzformat before
upload. TheCONTENTS.jsonfile includes md5sum values for each included file
for robust verification.It contains two main methods, which can bee accessed through thezenodo_backpackscript or accessed as a software library:create: turns a target directory into a zenodo_backpack-formatted .tar.gz archive with relevant checksum and version information, ready to be uploaded to Zenodo. It is necessary to provide a data version when doing so - furthermore, when uploading this backpack to zenodo.org, the version specified on the websitemustmatch that provided when the ZenodoBackpack was created. This allows version tracking and version validation of the data contained within the ZenodoBackpack.download_and_extract: takes a DOI string to download, extract and verify a zenodo_backpack archive from Zenodo.org to target directory. This returns a ZenodoBackpack object that can be queried for information.UsageCommand lineYou can run zenodo_backpack as a stand-alone program, or import its classes and use them in source code.In command line, zenodo_backpack can create an archive to be uploaded to Zenodo:zenodo_backpack create --input_directory <./INPUT_DIRECTORY> --data_version <VERSION> --output_file <./ARCHIVE.tar.gz>NOTE: it is important that when entering metadata on Zenodo, the version specifiedMUSTmatch that supplied with --data_versionAn uploaded existing zenodo_backpack can be downloaded (--bar if a graphical progress bar is desired) and unpacked as follows:zenodo_backpack download --doi <MY.DOI/111> --output_directory <OUTPUT_DIRECTORY> --barAPI UsageYou can also import zenodo_backpack as a module:import zenodo_backpackBackpacks can be created, downloaded and acquired from a local store:Create a backpackCreate a new backpack in.tar.gzformat containing the payload data folder:creator = zenodo_backpack.ZenodoBackpackCreator()
creator.create("/path/to/payload_directory", "path/to/archive.tar.gz", "0.1")Download a backpackDownload a backpack from Zenodo, defined by the DOI:backpack_downloader = zenodo_backpack.ZenodoBackpackDownloader()
backpack = backpack_downloader.download_and_extract('/path/to/download_directory', 'MY.DOI/111111')Read a backpack that is already downloadedDefined by a pathbackpack = zenodo_backpack.acquire(path='/path/to/zenodobackpack/', md5sum=True)or by environment variablebackpack = zenodo_backpack.acquire(env_var_name='MY_PROGRAM_DB', version="1.5.2")Working with a backpackTheZenodoBackpackobject returned byacquireanddownload_and_extracthas instance methods to get at the downloaded data. For example, it can return the path to the payload directory within theZenodoBackpackcontaining all the payload data:useful_data_path = zenodo_backpack.acquire(env_var_name='MyZenodoBackpack', version="1.5.2").payload_directory_string()InstallationThe easiest way to install is using conda:conda install -c bioconda zenodo_backpackAlternatively, you can git clone the repository and either run the bin/zenodo_backpack executable or install it with setup tools usingpython setup.py installzenodo_backpack relies onrequestsandtqdmto display an optional graphical progress bar. |
zenodoclient | zenodoclientPython package to access the Zenodo API (RESTandOAI-PMH) programmatically and from the command line.InstallTo install from pypipipinstallzenodoclientInstructions for a development installation can be found inCONTRIBUTING.md.Curating depositsTo curate deposits on Zenodo, you need anaccess token.
Then you can use the CLI:zenodo --access-token $YOURTOKEN lsAccessing OAI-PMH feedsZenodo disseminates the metadata for communities via OAI-PMH. This metadata
can be accessed programmatically from python as folows:>>>fromzenodoclient.oaiimportRecords>>>recs=Records('dictionaria')>>>len(recs)18We can list the latest version for each Dictionaria dictionary:>>>importitertools>>>ford,recordsinitertools.groupby(sorted(recs,key=lambdar:(r.repos.repos,r.version),reverse=True),lambdar:r.repos.repos):...print(d,next(records).tag)...wersingv1.0tseltalv1.0.1teopv1.0sidaamav1.0sanzhiv1.0palulav1.0nenv1.1medialenguav1.0kalamangv1.0hdiv1.1guarayuv1.0diidxazav1.0daakakav1.1.1and look at metadata:>>>recs[0].doi'10.5281/zenodo.3066952'>>>recs[0].citation'Henrik Liljegren. (2019). dictionaria/palula: Palula Dictionary (Version v1.0) [Data set]. Zenodo. http://doi.org/10.5281/zenodo.3066952' |
zenodo-client | Zenodo ClientA wrapper for the Zenodo API.💪 Getting StartedThe first example shows how you can set some configuration then never worry about whether it's been
uploaded already or not - all baked in withpystow. On the
first time this script is run, the new deposition is made, published, and the identifier is stored
with the given key in your~/.config/zenodo.ini. Next time it's run, the deposition will be looked
up, and the data will be uploaded. Versioning is given automatically by date, and if multiple
versions are uploaded on one day, then a dash and the revision are appended.fromzenodo_clientimportCreator,Metadata,ensure_zenodo# Define the metadata that will be used on initial uploaddata=Metadata(title='Test Upload 3',upload_type='dataset',description='test description',creators=[Creator(name='Hoyt, Charles Tapley',affiliation='Harvard Medical School',orcid='0000-0003-4423-4370',),],)res=ensure_zenodo(key='test3',# this is a unique key you pick that will be used to store# the numeric deposition ID on your local system's cachedata=data,paths=['/Users/cthoyt/Desktop/test1.png',],sandbox=True,# remove this when you're ready to upload to real Zenodo)frompprintimportpprintpprint(res.json())A real-world example can be found here:https://github.com/cthoyt/nsockg.The following example shows how to use the Zenodo uploader if you already know what your deposition
identifier is.fromzenodo_clientimportupdate_zenodo# The ID from your depositionSANDBOX_DEP_ID='724868'# Paths to local files. Good to use in combination with resources that are always# dumped to the same place by a given scriptpaths=[# os.path.join(DATABASE_DIRECTORY, 'alts_sample.tsv')'/Users/cthoyt/Desktop/alts_sample.tsv',]# Don't forget to set the ZENODO_API_TOKEN environment variable or# any valid way to get zenodo/api_token from PyStow.update_zenodo(SANDBOX_DEP_ID,paths)The following example shows how to look up the latest version of a record.fromzenodo_clientimportZenodozenodo=Zenodo()OOH_NA_NA_RECORD='4020486'new_record=zenodo.get_latest_record(OOH_NA_NA_RECORD)Even further, the latest version ofnames.tsv.gzcan be automatically downloaded to the~/.data/zenodo/<conceptrecid>/<version>/<path>viapystowwith:fromzenodo_clientimportZenodozenodo=Zenodo()OOH_NA_NA_RECORD='4020486'new_record=zenodo.download_latest(OOH_NA_NA_RECORD,'names.tsv.gz')A real-world example can be foundherewhere the latest build of theOoh Na Nanomenclature
database is automatically downloaded from Zenodo, even though the PyOBO package only hardcodes the
first deposition ID.Command Line InterfaceThe zenodo_client command line tool is automatically installed. It can be used from the shell with
the--helpflag to show all subcommands:$zenodo_client--helpIt can be run withzenodo_client <deposition ID> <path 1> ... <path N>⬇️ InstallationThe most recent release can be installed fromPyPIwith:$pipinstallzenodo_clientThe most recent code and data can be installed directly from GitHub with:$pipinstallgit+https://github.com/cthoyt/zenodo-client.gitTo install in development mode, use the following:$gitclonegit+https://github.com/cthoyt/zenodo-client.git
$cdzenodo-client
$pipinstall-e.⚖️ LicenseThe code in this package is licensed under the MIT License.🙏 ContributingContributions, whether filing an issue, making a pull request, or forking, are appreciated. SeeCONTRIBUTING.rstfor more
information on getting involved.🍪 Cookiecutter AcknowledgementThis package was created with@audreyr'scookiecutterpackage
using@cthoyt'scookiecutter-python-packagetemplate.🛠️ DevelopmentThe final section of the README is for if you want to get involved by making a code contribution.❓ TestingAfter cloning the repository and installingtoxwithpip install tox, the unit tests in
thetests/folder can be run reproducibly with:$toxAdditionally, these tests are automatically re-run with each commit in
aGitHub Action.📦 Making a ReleaseAfter installing the package in development mode and installingtoxwithpip install tox, the commands for making a new release are contained within
thefinishenvironment intox.ini. Run the following from the shell:$tox-efinishThis script does the following:Uses BumpVersion to switch the version number in thesetup.cfgandsrc/zenodo_client/version.pyto not have the-devsuffixPackages the code in both a tar archive and a wheelUploads to PyPI usingtwine. Be sure to have a.pypircfile configured to avoid the need for
manual input at this stepPush to GitHub. You'll need to make a release going with the commit where the version was bumped.Bump the version to the next patch. If you made big changes and want to bump the version by
minor, you can usetox -e bumpversion minorafter. |
zenodo-get | This program is meant to download complete Zenodo records based
on the Zenodo record ID or the DOI. The primary goal is to ease access
to large records with dozens of files. |
zenodopy | zenodopyProject under active deveopment, not production readyA Python 3.6+ package to manageZenodorepositories.Functions Implemented.create_project(): create a new project.upload_file(): upload file to project.download_file(): download a file from a project.delete_file(): permanently removes a file from a projectInstallingPyPipipinstallzenodopy==0.2.0GitHubpipinstall-egit+https://github.com/lgloege/zenodopy.git#egg=zenodopyUsing the PackageCreate a Zenodo access tokenby first logging into your account and clicking on your username in the top right corner. Navigate to "Applications" and then "+new token" under "Personal access tokens". Keep this window open while you proceed to step 2 becausethe token is only displayed once.Store the tokenin~/.zenodo_tokenusing the folowing command{echo'ACCESS_TOKEN: your_access_token_here'}>~/.zenodo_tokenstart using thezenodopypackageimportzenodopy# always start by creating a Client objectzeno=zenodopy.Client()# list projectszeno.list_projects# list fileszeno.list_files# create a projectszeno.create_project(title="test_project",upload_type="other")# your zeno object now points to this newly created project# create a file to uploadwithopen("~/test_file.txt","w+")asf:f.write("Hello from zenodopy")# upload file to zenodozeno.upload_file("~/test.file.txt")NotesThis project is under active development. Here is a list of things that needs improvement:more tests: need to test uploading and downloading filesdocumentation: need to setup a readthedocsdownload based on DOI: right now you can only download from your own projects. Would be nice to download fromasyncronous functions: useasyncioandaiohttpto write async functions. This will speed up downloading multiple files. |
zenodo-rest | # zenodo-restA python wrapper of Zenodo’s REST API for python and the command line.## InstallationFor usage as a module, install with your preferred env manager (pip, pipenv, conda, … ).
For CLI usage [pipx](https://pypa.github.io/pipx/) is recommended.` bash pip--userpipx pipx installzenodo-rest`## UsageThe CLI has built in documentation.` bashzenodo-rest--helpzenodo-restdepositions--help`For information about the module or more details about the CLI, see the source-code or [readthedocs](https://zenodo-rest.readthedocs.io/en/latest/zenodo_rest.depositions.html). |
zenodo-search | Zenodo SearchPerform zenodo searches with python.Note: Zenodo updated the backend. This resulted in the searches failing with the old version of this package. For
example, the doi string should not be the full doi anymore, but only the id. Some of the old search strings also don't
work anymore. This is hopefully a temporary issue and will be fixed soon.Installationpipinstallzenodo_searchDependenciesrequestsUsageimportzenodo_searchaszsearchsearch_string='doi:8357399'records=zsearch.search(search_string)More examples can be found in theexamplesfolder. |
zeno-evals | Zeno 🤝 OpenAI EvalsUseZenoto visualize the results ofOpenAI Evals.https://user-images.githubusercontent.com/4563691/225655166-9fd82784-cf35-47c1-8306-96178cdad7c1.movExample usingzeno-evalsto explore the results of an OpenAI eval on multiple choice medicine questions (MedMCQA)Usagepipinstallzeno-evalsRun an evaluation following theevals instructions. This will produce a cache file in/tmp/evallogs/.Pass this file to thezeno-evalscommand:zeno-evals/tmp/evallogs/my_eval_cache.jsonlExampleSingle example looking at US tort law questions:zeno-evals./examples/example.jsonlAnd an example of comparison between two models:zeno-evals./examples/crossword-turbo.jsonl--second-results-file./examples/crossword-turbo-0301.jsonlAnd lastly, we can pass additionalZeno functionsto provide more context to the results:pipinstallwordfreq
zeno-evals./examples/crossword-turbo.jsonl--second-results-file./examples/crossword-turbo-0301.jsonl--functions_file./examples/crossword_fns.py |
zenofelon | No description available on PyPI. |
zeno-first-presentation | zeno-first-presentationzeno-first-presentation is my first python libraryInstallationpipinstallzeno-first-presentationUsagefromzeno_presentationimportzenozeno.hello_from_zeno()# prints Hello from zeno |
zen-of-koli | Zen of KoliUltimite guide to life, python and all.If you feel you don't know how to proceed and nothing make sense, take your time...
Read this Zen, and, finally, you will find the answer.Usagepython3-c"from koli import sk"python3-c"from koli import en" |
zen-of-numpy | No description available on PyPI. |
zen-of-python-he | Zen of Python heUltimate guide to develop good, and smooth projects.If you feel you don't know how to proceed and nothing make sense, take your time...
Read this Zen, and, finally, you will find the answer.Usagefromkoli_heimporthe
fromkoli_enimporten |
zenoh | Zenoh Python APIZenohis an extremely efficient and fault-tolerantNamed Data Networking(NDN) protocol
that is able to scale down to extremely constrainded devices and networks.The Python API is for pure clients, in other terms does not support peer-to-peer communication, can be easily
tested with our demo instace available atdemo.zenoh.io.DependenciesThe zenoh-python API depends on thezenoh-cAPI. Thus the first thing to do is to ensure thatzenoh-cin installed on your machine. To do so, please follow the instructions providedhere.Installing the Python API from SourcesTo install the API you can do:$ python3 setup.py installNotice that on some platforms, such as Linux, you will need to do this assudo.Running the ExamplesTo run the bundled examples without installing any additional software you can thezenohdemo instance
available atdemo.zenoh.io. To do so, simply run as follows:$ cd zenoh-python/example
$ python3 sub.py -z demo.zenoh.ioFrom another terminal:$ cd zenoh-python/example
$ python3 sub.py -z demo.zenoh.io |