Saravanan666/pypi-org huggingface dataset:
Package: evekeys
evekeys: Isolate keywords from an event-based and custom-grouped textual corpusBy Chris Lindgrenchris.a.lindgren@gmail.comDistributed under the BSD 3-clause license. See LICENSE.txt orhttp://opensource.org/licenses/BSD-3-Clausefor details.Documentation:https://evekeys.readthedocs.io/en/latest/OverviewA set of functions that uses scikit-learn to conduct a TF-IDF analysis to isolate keywords from event-based documents. It answers the following questions:What keywords represent a particular period of content?What keywords represent a particular group of content from a particular period?It assumes you have:imported your corpus as a pandas DataFrame,included metadata information, such as a list of dates and list of groups to reorganize your corpus, andpre-processed your documents.It functions only with Python 3.x and is not backwards-compatible.Warning: evekeys performs little to no custom error-handling, so make sure your inputs are formatted properly. If you have questions, please let me know via email.System requirementspandassklearntqdmInstallationpip install evekeysKnown Issues or LimitationsPlease contact me if you discover any issues.Example notebooksComing soon.Distribution update terminal commands# Create new distribution of code for archiving
sudo python setup.py sdist bdist_wheel

# Distribute to Python Package Index
python -m twine upload --repository-url https://upload.pypi.org/legacy/ dist/*
Package: eve-mli
eve-mli: making learning interestingEve is an open-source deep learning framework used to devise and modify a network architecture in a flexible and interesting way.We provide several jupyter notebooks under./examplesto demonstrate how to build various network structures.The most features of Eve are that: it provides a well defined framework which make your network structure can be upgraded along with the learning of weights.Any contributions to Eve is welcome!InstallationInstall fromPyPI:pipinstalleve-mli# pip install git+git@github.com:densechen/eve-mli.gitDevelopers can download and install the latest version from:GitHub:gitclonehttps://github.com/densechen/eve-mli.gitcdeve-mli
pythonsetup.pyinstallGitee:gitclonehttps://gitee.com/densechen/eve-mli.gitcdeve-mli
pythonsetup.pyinstallVailidate installation:python-c"import eve; print(eve.__version__)"About the projectThe documentation can be foundhere.
(Auto-building of documentation fails sometimes, you can build it manually viacd docs; make html).The project remains in development. We encourage more volunteers to come together!The first official version of eve-mli will be released very soon.About the authorsDengsheng ChenMaster @ National University of Defense Technologydensechen@foxmail.comReferencesPyTorchstable-baselines3spikingjellyModel-Compression-Deploy
Package: even-better-setuptools-git-version
better-setuptools-git-versionAutomatically set package version from Git. This is a re-release ofvery-good-setuptools-git-versionwith fixes and improvements, which is itself a re-release ofsetuptools-git-versionIntroductionInstead of hard-coding the package version insetup.pylike:setup(name='foobar',version='1.0',...)this package allows to extract it from tags in the underlying Git repository:setup(name='foobar',version_config={"version_format":"{tag}.dev{sha}","starting_version":"0.1.0"},setup_requires=['better-setuptools-git-version'],...)The tool uses the semantically-latest tag as the base version. If there are no annotated tags, the version specified bystarting_versionwill be used. IfHEADis at the tag, the version will be the tag itself. If there are commits ahead of the tag, the first 8 characters of the sha of theHEADcommit will be included.In all of the above cases, if the working tree is also dirty or contains untracked files, a+dirtysuffix will be appended to the version.
Package: eve_neo4j
Eve Neo4j extension.Eve-Neo4j is a Neo4j data layer for eve REST framework.FeaturesNeo4j’s nodes CRUD.LicenseMIT licenseInstall$pipinstalleve-neo4jUsageSet neo4j as your eve data layer.importevefromeve_neo4jimportNeo4japp=eve.Eve(data=Neo4j)app.run()ConfigGRAPH_DATABASE='http://localhost:7474/db/data/'GRAPH_USER='neo4j'GRAPH_PASSWORD='neo4j'# TODO: Override this as a defautl when ussing Neo4j as datalayerITEM_URL='regex("[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}")'History0.1.4Feature: Create relations.Fix: dict data type on update.Fix: Use internal remove method to delete old node.Feature: Implement unique validation.0.1.3Support dict data type.Use docker compose for testingImprove remove method performanceImplement custom validator for Neo4j’s data types.0.1.2Parse timestamp fields from Node to datetime objects.Update usage in docs.Rename dict_to_node to create_node.
Package: evennia
Evennia MUD/MU* Creation SystemEvenniais a modern library for creatingonline multiplayer text
games(MUD, MUSH, MUX, MUCK, MOO etc) in pure Python. It
allows game creators to design and flesh out their ideas with great
freedom.Evennia does not impose a particular style, genre or game mechanic. Instead it
solves the boring networking and basic stuff all online games need. It provides
a framework and tools for you to build the game you want. Coding in Evennia is
done using normal Python modules imported into the server at runtime.Evennia hasextensive documentation. It also has a very active community
withdiscussion forumsand adiscord serverto help and support you!Installationpip install evennia
    (windows users once: py -m evennia)
evennia --init mygame
cd mygame
evennia migrate
evennia start / stop / reloadSeethe full installation instructionsfor more help.Next, browse tohttp://localhost:4001or use your third-party mud client to
connect tolocalhost, port4000to see your working (if empty) game!A game website is created automatically. Connect to your Evennia game from your
web browser as well as using traditional third-party clients.Where to go nextIf this piqued your interest, there is alengthier introductionto read. You
can also read ourEvennia in picturesoverview. After that,
why not check out theEvennia Beginner tutorial.Welcome!
Package: evennia-wiki
evennia-wikiA simple wiki forEvennia, simple to install within anEvenniagame.InstallationYou have to install Evennia beforehand.  Once done, to add the Wiki, install from pypi:pip install evennia_wikiThen, in your Evennia folder, editserver/conf/settings.pyto add
the installed app:INSTALLED_APPS+=(# ..."evennia_wiki",)Finally, inweb/urls.py, you should add the custom URL:custom_patterns=[# ...url(r'^wiki/',include('evennia_wiki.urls')),]Donâ€™t forget to runevennia migrateafter that.UsageYou can now run your game:evennia startGo to your website:http://localhost:4001/wiki/.SettingsBy default, the wiki is off-limit to players.  Only authenticated builders have access to it, to write it and read it.  You can change these defaults.The current possibility is to change this default for every page.  It is not possible to do it for a specific page.  Go to yoursettings.lpyfile and change one of these settings:WIKI_CAN_READ: who can read the wiki? Set to"builder"by default. Change it to"anonymous"to allow anonymous visitors to read your wiki (but not edit it).WIKI_CAN_WRITE: who can write your wiki?  Set to"builder"by default.  For the time being, anonymous users cannot edit a wiki page, so you need to set it to a group of authenticated users (like"builder"or"admin").DocumentationSee theproject documentation hosted on Github pages.
Package: evenoddsjy
Overviewtest descThis project was generated withcookiecutterusingjacebrowning/template-python.SetupRequirementsPython 3.11+InstallationInstall it directly into an activated virtual environment:$ pip install evenoddsjyor add it to yourPoetryproject:$ poetry add evenoddsjyUsageAfter installation, the package can be imported:$ python
>>> import evenoddsjy
>>> evenoddsjy.__version__
Package: evenstar
EvenstarJust another GraphQL query builder, but composable!How to install it?It's simple, just run:pip install evenstarGraphQL Syntax CoverageFieldsArgumentsAliasesFragmentsOperation NameVariablesDirectivesMutationsInline FragmentsExampleapple_field=Field(name="appleMutation",alias="apple_mutation_alias",arguments=Arguments({"input":VarSymbol("$apple_input")}),children=["__typename",InlineFragment(on="SomeErrKind",children=["code","field","message"]),InlineFragment(on="SomeAnotherErrKind",children=["error_code"]),],)create_banana_field=Field(name="createBanana",alias="create_banana",arguments=Arguments({"input":VarSymbol("$create_banana_input")}),children=["__typename","code",InlineFragment(on="SomeAnotherErrKind",children=["error_code"]),InlineFragment(on="Banana",children=["id","quality",Field("farm",children=["country","town","number",],),],),],)gql_req=Request(children=[Mutation(children=[create_banana_field,apple_field],variables=[VarDeclaration("$apple_input","CreateAppleInput!"),VarDeclaration("$banana_input","CreateBananaInput!"),],)],variables={"apple_input":{"id":str(uuid4())},"banana_input":{"id":str(uuid4())},},)print(gql_req.json(indent=2))
Package: event2vec
event2vecDocumentation:https://straymat.gitlab.io/event2vec/Source Code:https://gitlab.com/strayMat/event2vecOverviewElectronic Health Record and claims contain sequences of care: every contact
between a patient and a healthcare system (either hospital, either insurance) is
recorded in a central database. Medical terminologies are often used to encode
the type of care : diagnoses, acts, drugs, laboratory, ...Such healthcare trajectories can be viewed as sequence of tokens, similarly to
sequences of words.This package propose to use matrix factorization as a simple and efficient way
to build event embedding from a medical observational database.
Package: eventables
SimpleEventsSimple Event Handler and utility objects for monitoring and responding to changes in data structures.Changelog0.1.0 Initial ReleaseImplemented generic Event() object for event processingImplemented EventList(). Custom list with events to respond to adding, removal, and change of entries.
And responding to clearing of List.Installationpip install eventablesEvent() Usagefromeventables.eventsimportEventclassMyObject:def__init__(self):self.my_event=Event()deftrigger_example(self):# do stuffself.my_event(my_arg="Successful Event Call")defreaction_function(my_arg):print(my_arg)defdemo():my_object=MyObject()my_object.my_event+=reaction_functionmy_object.trigger_example()Output>>> demo()
Successful Event CallEventList() UsageListfromeventables.eventsimportEventListclassMyObject:def__init__(self):self.my_list=EventList()defreaction_function(value):print(f"Successfully added{value}to list!")defdemo():my_object=MyObject()my_object.my_list.on_entry_added+=reaction_functionmy_object.my_list.append("Test Object")Output>>> demo()
Successfully added Test Object to list!
Package: event-ami-asterisk
GnewManagerAMIEventsOverviewIt is an orchestrator that organizes the events received from the AMI and saves the state of the endpoints in memory.Installing GnewManagerAMIEvents and Supported VersionsGnewManagerAMIEvents is available on PyPI:$ python -m pip install event-ami-asteriskGnewManagerAMIEvents officially supports Python 3.8+.Cloning the repository$ git clone https://github.com/Gnew-Solucoes-IP-Ltda/event-ami-gnew.git
Package: event-analytics
Event_analyticsAn Event Analytics package to help Organizers analyze, segment & understand Audience & their behavior.This package is being released in conjunction withIMDA Singapore,Global Sign.In&Babelas part of theIMDA OIP Challenge.The objective is to help the Event industry better leverage and utilize Data & Analytics to enhance their Audience & Exhibitor engagements.There are 2 key Business Objectives that this package aims to help with:Determining correlations amongst all data an Event has generatedHelping understand the different Audience Segments that each Attendee is suitable for based on advanced Segmentation approaches like RFM
Package: eventbrite-python
eventbrite-pythoneventbrite-pythonis an API wrapper for Eventbrite, written in Python.This library uses Oauth2 for authentication.Installingpip install eventbrite-pythonUsage# if you have an access token:fromeventbrite.clientimportClientclient=Client(access_token=access_token)# Or if you are using Oauth2 to get an access_token:fromeventbrite.clientimportClientclient=Client(api_key,client_secret,redirect_uri)To obtain and set an access token:Build authorization URLurl=client.authorization_url(state="123456")Get access tokentoken=client.get_access_token(code)Set tokenclient.set_token(access_token)InfoGet current userme=client.get_current_user()Get user organizationsorganizations=client.get_user_organizations()List categoriescategories=client.list_categories()List subcategoriessubcategories=client.list_subcategories()List formatsformats=client.list_formats()List venuesvenues=client.list_formats(organization_id)List organizersorganizers=client.list_organizers(organization_id)EventsList eventsevents=client.list_events(organization_id)Get eventevent=client.get_event(event_id)Create eventevent=client.create_event(organization_id,data)OrdersGet orderorder=client.get_order(order_id)WebhooksList webhookswebhooks=client.list_webhooks(organization_id)Create webhookwebhook=client.create_webhook(organization_id,endpoint_url,actions,event_id="")Delete webhookdeleted=client.delete_webhook(webhook_id)
Package: eventb-to-txt
Event-B to txt converterThe eventb-to-txt script simply converts Event-B machines and contexts (.bum and .buc files) to the plain text. This text itself is a valid Event-B model that can be used in the CamilleX editor.Compatible with Event-B models created with Rodin 3.0 and above.Installation$ python3 -m pip install eventb-to-txtUsageusage: eventb-to-txt [-h] [-o PATH] [-m] [in_path]

    positional arguments:
    in_path              path to the Event-B model directory or zipfile

    optional arguments:
    -h, --help           show this help message and exit
    -o PATH, --out PATH  PATH to the output directory
    -m, --merge          merge all generated txt files into a single txt file
Package: eventbus-py
eventbus-pyEventBus的Python实现Example调用规范
由于设计时考虑到可能会存在多个实例的情况，故使用ContextVar来包装EventBus实例方便使用者调用。fromeventbusimportbus,SubscribeclassExample:passclassA:def__init__(self):bus.get().register(a)@Subscribe(priority=100,sticky=True)defon_example(self,event:Example):bus.get().cancel_delivery(event)bus.get().unregister(a)a=A()bus.get().post(a)
Package: event-channel
Event ChannelAnother library with a pub/sub implementation. You can subscribe functions to a certain topic (aka event). When a message is sent through this event callback functions subscribed will be executed.fromevent_channelimportEventChannelmychannel=EventChannel()# You can also import channel, is an instance already createddefcallback(x):x=x+1print(x)mychannel.subscribe("myevent",callback)mychannel.publish("myevent",345)channel.unsubscribe("myevent",callback)fromevent_channel.threaded_event_channelimportThreadedEventChannelmychannel=ThreadedEventChannel(blocking=False)# You can also import non_blocking_channel, is an instance already createddefcallback(x):x=x+1print(x)mychannel.subscribe("myevent",callback)mychannel.subscribe("myevent",callback2)threads=mychannel.publish("myevent",345)# Wait thread finishforthreadinthreads:thread.join()fromevent_channel.threaded_event_channelimportThreadedEventChannelmy_blocking_channel=ThreadedEventChannel()# You can also import channel, is an instance already createddefcallback(x):x=x+1print(x)mychannel.subscribe("myevent",callback)mychannel.subscribe("myevent",callback2)threads=mychannel.publish("myevent",345)#at this point all threads are finished
Package: eventclf
Event attendance prediction classifierCode for answering the following RQ:RQ1. How accurate is our event attendance prediction classifier?from eventclf.evaluate_models import eval_model
eval_model(path_to_results_file)RQ2. What features groups help most to attain high prediction accuracy?from eventclf.evaluate_features import run_feat_analysis
run_feat_analysis(path_to_results_file)Find the results in the results folder.
Package: event-dispatching
Event DispatcherThis repository contains a pure Python implementation of an event dispatcher. The event dispatcher allows you to create a simple event-driven architecture in your Python applications. It allows you to decouple your application components, making your code cleaner and easier to maintain.FeaturesPure Python: No external dependencies.Simple API: Easy to understand and use.Lightweight: Minimal impact on your application's performance.Flexible: Can be used in any Python application.Asyncio Support: Compatible with Python's built-in asyncio library.InstallationYou can install the Event Dispatcher usingpip:pipinstallevent-dispatchingor using poetrypoetryaddevent-dispatchingUsageHere is a basic example of how to use the Event Dispatcher:importevent_dispatcher# Create an instance of the Event Dispatcherdispatcher=event_dispatcher.SyncEventDispatcher()# Define a callback functiondefcallback(data):print(f"Event received:{data}")# Register the callback function for the "test" eventdispatcher.subscribe("test",callback)# Dispatch the "test" eventdispatcher.dispatch("test","Hello, World!")When you run this code, it will print:Event received: Hello, World!More usage examples providedhereContributingContributions are welcome! Please feel free to submit a Pull Request.LicenseThis project is licensed under the MIT License. See the LICENSE file for details.
Package: eventeditor
EventEditor for Breath of the WildSetupInstall Python 3.6+ (64 bit version) and PyQt5, then runpip install eventeditor.ConfigurationThe configuration file is stored:On Linux or macOS: at~/.config/eventeditor/eventeditor.iniOn Windows: at%APPDATA%/eventeditor/eventeditor.iniAuto-completionBreath of the WildIn order to enable auto-completion for actors, actions, and queries, add:[paths]rom_root=/path/to/game_romto EventEditor's configuration file, where/path/to/game_romis a path such that/path/to/game_rom/Pack/Bootup.pack/Actor/AIDef/AIDef_Game.product.sbymlexists.
An easy, recommended way to get the required file structure without extracting every archive
is to usebotwfstools.Other gamesAlternatively, JSON actor definitions can be generated underFlowchart>Export actor definition data to JSON. This will generate information for auto-completion from the currently open event flow. The first time this is run, a prompt will appear asking for where to save this information.This action can be safely repeated in case other event flows contain actors, actions, or queries that have yet to be included in the JSON file (existing entries will not be overwritten).Known issuesOn Linux, if the main window view is a completely blank screen, even after opening a file, try runningQTWEBENGINE_DISABLE_SANDBOX=1 eventeditorto start the tool.Unlinking events while in fork/join will break graph generation most of the time. So using that option is not recommended when fork/join events are involved.What needs to be doneTimeline files (reverse engineering)Collect event info from EventInfo and have a metadata file for each event flow, so that:EventInfo can be automatically regeneratedAll copies of an event flow can be automatically updatedNode order shuffling to get less crossings. This used to be a dagre.js feature but it got removed...LicenseThis software is licensed under the terms of the GNU General Public License, version 2 or later.
Package: eventemitter
Tools for publishing and listening for events.Example UsageEventEmitterTheEventEmitterclass can be used directly or as a mix-in to provide the
ability to publish and subscribe to events.importloggingfromeventemitterimportEventEmitterlog=logging.getLogger(__name__)emitter=EventEmitter()deflog_event(event,*args,**kwargs):log.debug('%s%s%s',event,args,kwargs)emitter.on('an-event',log_event)emitter.emit('an-event',1,2,keyword=3)awaitasyncio.sleep(0)# 'an-even (1, 2), {keyword: 3}' gets logged.Listener functions can be defined usingdeforasync def. All listeners are
executed in a deferred way. The coro that callsemitmust yield for the event
to propagate.EventIterableIf the callback-style model of listening for events is undesirable, an async
iterable is provided to offer a second model for handling events.importloggingfromeventemitterimportEventEmitterfromeventemitterimportEventIterablelog=logging.getLogger(__name__)emitter=EventEmitter()iterable=EventIterable(emitter,'an-event')asyncforargs,kwargsiniterable:log.debug('%s%s%s',event,args,kwargs)TheEventIterableimplements the async iterable interface and can be used in
conjunction with any of the tools inaitertools.TestingAll tests suites are paired one-to-one with the module they test and live
directly adjacent to that same module. All tests are expected to pass for
Python 3.5 and above. To run tests use tox with the included tox.ini file or
create a virtualenv and install the ‘[testing]’ extras.LicenseCopyright 2015 Kevin ConwayLicensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.ContributingFirstly, if you’re putting in a patch then thank you! Here are some tips for
getting your patch merged:StyleAs long as the code passes the PEP8 and PyFlakes gates then the style is
acceptable.DocsThe PEP257 gate will check that all public methods have docstrings. If you’re
adding something new, like a helper function, try out thenapoleon style of docstrings.TestsMake sure the patch passes all the tests. If you’re adding a new feature don’t
forget to throw in a test or two. If you’re fixing a bug then definitely add
at least one test to prevent regressions.
Package: event-emitter-asyncio
Event Emitter (asyncio)Super simple event emitter in Python 3, built with asyncio. No decorators required. Built around a subset of the NodeJSEventEmitterAPI.A full write up and explanation for how this module works can be foundhere.Installationpipinstallevent_emitter_asyncioUsage (Working example)importasynciofromevent_emitter_asyncio.EventEmitterimportEventEmitterevent_emitter=EventEmitter()asyncdefrun():# add a listenerasyncdeffunc(event):forpetinevent['pets']:print(pet)event_emitter.add_listener('some-event',func)# emit an event every second for 3 secondsn=0whilen<3:event_data={'pets':['cats','dogs']}event_emitter.emit('some-event',event_data)awaitasyncio.sleep(1)n+=1# remove the listenerevent_emitter.remove_listener('some-event',func)loop=asyncio.get_event_loop()loop.run_until_complete(run())This will give:>cats
>dogs
>cats
>dogs
>cats
>dogsDeveloping on this repoDevelopmentgitclonegit@github.com:joeltok/event-emitter-asyncio.gitcd./event-emitter-asyncio
python3-mvenv./venvsourcevenv/bin/activate
pip3installpytest
pip3installpytest-asyncioTestingpython3-mpytestsrc/event_emitter_asyncio/Packagingsourcevenv/bin/activate
python3-mpipinstall--upgradebuild
python3-mpipinstall--upgradetwinerm-rfdist&&python3-mbuild
twineuploaddist/*
Package: eventer
Eventer is a simple event dispaching library.It provides a simple API to bind and trigger custom named events. Events do not have to be declared before they are bound.import eventer

def on_edit(page):
    subject = page.path + " is edited"
    sendmail(subject=subject)

eventer.bind("edit", on_edit)

eventer.trigger("edit", page)The API is inspired by event handling injQueryandbackbone.js.