Saravanan666/pypi-org huggingface dataset:
Package: pyactcv
pyactcv - python interfaceThis library connects the cognitive architecture ACT-R with the programming language python to load user data into ACT-R's visicon.The cognitive architecture ACT-R is able to monitor a human operator’s interactions with a system using the concept of model-tracing, a concept previously implemented within an ACT-R tutoring system [1]. This software library adapted the work of [2] to establish such a connection between the programming language python and ACT-R version 7.12. For exemplary usage of the library please see [3] and [4].Installation$pipinstallpyactcvor$pipinstallgit+https://github.com/seblum/actcvUsageTake a look at theexamplesfolder for an exemplary use case.importpandasaspdimportactrimportpyactcvascvdata=pd.read_csv('userData.csv',sep=';',dtype={'alarmactivecolumn':float,'alarmnumbercolumn':float,'timecolumn':float})header=list(data)data=data.where((pd.notnull(data)),None)frequency=3000duration=3starttime=0indexinput=0timebreak=0.1actcv=cv.ActCV(data,'timecolumn')actcv.load_states()actcv.schedule_visicon()actcv.schedule_tone()actr.run()Filesactcv.py- Contains the class ActCV and methods to create the interface to load user data set into the visicon of ACT-R.actr.py- Contains the dispatcher of ACT-R version 7.12., which is necessary to form a connection between python and ACT-R (seehttp://act-r.psy.cmu.edu/).TODOPossible additional feature to add:Add more dynamic read in for dataAdd selection of what to load ("visual", "audio")Add debugging supportDeveloping pyactcvTo install pyactcv along with the tools to develop and run tests please run the following in your virtualenv:$pipinstall-e.[dev]Bibliography[1]Fu, W.-T., Bothell, D., Douglass, S., Haimson, C., Sohn, M.-H., & Anderson, J. (2006). Toward a real-time model-based training system. Interacting with Computers, 18(6), 1215–1241.[2]Halbruegge, M. (2013). Act-cv - bridging the gap between cognitive models and the outer world. In E. Brandenburg (Ed.), Grundlagen und Anwendungen der Mensch- Maschine- Interaktion: 10. Berliner Werkstatt Mensch- Maschine-Systeme (pp. 205–210). Berlin: TU Berlin.[3]Klaproth, O. W., Halbruegge, M., Krol, L. R., Vernaleken, C., Zander, T. O. and Russwinkel, N. (2020). A Neuroadaptive Cognitive Model for Dealing With Uncertainty in Tracing Pilots’ Cognitive State. Topics in Cognitive Science, 12(3), p. 1012-1029.[4]in review
Package: pyActionNetwork
[![CircleCI](https://circleci.com/gh/PhillyDSA/pyactionnetwork.svg?style=svg)](https://circleci.com/gh/PhillyDSA/pyactionnetwork) [![codecov](https://codecov.io/gh/PhillyDSA/pyactionnetwork/branch/develop/graph/badge.svg)](https://codecov.io/gh/PhillyDSA/pyactionnetwork)# PyActionNetwork## Installation`bash pip install pyactionnetwork `## ContributingAll contributors agree to abide by the [Philadelphia DSA Code of Conduct](https://github.com/PhillyDSA/code-of-conduct).There are additional requirements that can be installed by:`bash pip install-rrequirements/testing.txt `To run tests:`bash make test `All contributions should maintain the coding style of the project, maintain or increase code coverage, and work with Python 3.3 or higher. Python 2 is unsupported.
Package: pyactivation
PyactivationVersion 0.0.2A small library for creating and validating license keys.Installationpip install licensekeygenGet startedHow to generate a key using v1frompyactivation.licensekeyimportv1# creates a keykey=v1.generate_key()print(key)How to generate a key using v2frompyactivation.licensekeyimportv2# creates a keykey=v2.generate_randomkey(1,"07/30/2025")print(key)
Package: pyactivemq
pyactivemq is a Python module for communicating with the ActiveMQ message broker
which implements the Java Message Service specification.pyactivemq wraps the ActiveMQ-CPP library using Boost.Python. This implies that
both the Stomp and Openwire wire formats are supported for communicating with
the broker.pyactivemq could also be used with other JMS message brokers by utilising
ActiveMQ’s JMS to JMS bridge feature.
Package: pyactiverecord
pyactiverecord is python active-record like mysql wrapper.Featuresactive-record like mysql wrapperORMRequirementsPython 3.xmysqlmysql-connector-pythonInstallpip install pyactiverecordUsagecreate model class.import model


class SampleModel(model.Model):

    number = model.Column(type=model.Type.int)
    title = model.Column(type=modle.Type.varchar)
    text = model.Column(type=model.Type.text)
    date = model.Column(type=model.Type.timestamp)at this time, if the lower-case of this model class name of table is’t
exist, table is automatically created.pyactiverecord needs to connecte to the database, program is required to
call Databese.setup() method.import model

def execute():
    s = SampleModel()
    s.title = "test"
    s.text = "test to save sample model"
    s.save()

    s = SampleModel.query().first()
    print(s.title, s.text)


if __name__ == '__main__':

    model.Database.setup(
        host="localhost",
        database="database_name",
        user="root",
        password=""
    )

    execute()Methodsclass methodsquery: fetch data from the tabledata = SampleModel.query()
for d in data:
    print(d.title)

# where
data = SampleModel.query(where=["title='py-activerecord'", "text like '%Python%'"])

# order
data = SampleModel.query(order=["id asc", "title desc"])instance methodssave: save model object to the tables = SampleModel()
s.number = 1
s.title = "py-activerecord"
s.text = "ActiveRecord for Python Library"
s.date = "2016-01-01 00:00:00"

s.save()delete: delete model object from the tables = SampleModel.query(where=["title='py-activerecord'"], order=["id asc"]).first()
s.delete()LicenseThis software is released under the MIT LicenseThe MIT License (MIT)
Copyright (c) 2016 Hiroyuki NikaidoPermission 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.
Package: pyactivetwo
InstallationThe easiest way to install is viaeasy_installorpip:$ pip install pyactivetwoUsageTurn on the BioSemi ActiveTwo device.Start BioSemi ActiView and configure sampling rate and other important parameters to your liking. Pay special attention to the “TCP Server” tab. The parameters should correspond with the parameters you inializeActiveTwoobject with.Have a look at theexamples/example.pyfor the minimal usage example.
Package: py-active-window
A package for searching files in a target directory.This package provides python bindings for the rust crateRust_Searchby building
a native Python extension usingPyO3.UsageTo installpipinstallpy-active-windowBuilding from source requires the nightly version of the rust compiler.This module exposes a single function that transforms C++ linker symbols to a human readable
representation.frompy_active_winimportget_active_winprint(get_active_win())Released under the MIT License
Package: pyactiviti
An SDK that helps with interacting with Activiti.Free software: BSD licenseDocumentation:https://pyactiviti.readthedocs.org.FeaturesCreate/Read/Update/Delete/Search a userCreate/Read/Update/Delete/Search a groupList the deploymentsTodoCreate/Read/Update/Delete/Search ProcessCreate/Read/Update/Delete/Search InstanceCreate/Read/Update/Delete/Search TaskExamplesfrompyactivitiimportActivitiACTIVITI_AUTH=('kermit','kermit')ACTIVITI_API='http://localhost:8080/activiti-rest'activiti=Activiti(ACTIVITI_API,auth=ACTIVITI_AUTH)ifnotactiviti.user_exists('user1'):user=activiti.create_user('user1','foo@bar.org','secret')else:user=activiti.get_user('user1')group=activiti.create_group('group1','Group1','Type')activiti.group_add_member(group['Id'],user['Id'])History0.1.0 (2015-09-04)First release on PyPI.
Package: pyactms
ActMS - python interfaceThis is a library to enable mental simulation of multiple cognitive models within the Cognitive Architecture ACT-R.ACT-MS (ACT-R Mental Simulation) is an implementation based on the Python dispatcher included in ACT-R Version 7.13, which facilitates the use of ACT-R commands within a Python environment and vice versa. ACT-MS incorporates multiple functions relevant to coordinate the simultaneous simulation of multiple ACT-R models. An exemplary use case can be found in the below publication [1].Overall, the library contains methods to:to forward and exchange parameters between the metamodel and the submodels.save the exchanged simulation parameters in a dictionary.enable utility learning over multiple ACT-R runs by saving the utility of one run respectively.Installationpipinstallpyactmsorpipinstallgit+https://github.com/seblum/actmsUsageTake a look at theexamplesfolder for an exemplary use case.Call of the methodsimulate-submodelin a production of the metamodel to start the mental simulation of another specified ACT-R modelmiddle-model.(psimulate-middle-submodel=goal>statesimulate-submodelaction=actionnumber=imaginal>==>=imaginal>=goal>statefreeaction=actionnumber!eval!("simulate-submodel""middle-model"=actionnumber))Call of the methodreturn-from-submodelin a production of the submodel to forward given parameters to the metamodel and save them within a specific slot of the imaginal chunkresultactionone.(Paction-retour-1=goal>stateaction-1action1?manual>statefree=imaginal>response=duration==>+manual>cmdpress-keykey=duration-imaginal>=goal>stateidleactionidle!eval!("return-from-submodel"=duration1"retrieve-action""resultactionone"))Initialization of ACT-MS. Saving the session number in the simulation results. Run of ACT-R model. Fetching the saved simulation / forwarded paramenters and saving them to a dataframe. Printing the dataframe.importactrimportactmsasmssession=1actms=ActMS('mainmodelname')actr.run_until_condition("end-program",True)# return simulation results as dfprinter=actms.Protocol("Session",session)printer.to_csv('simulation_results.csv')Filesactms.py- Contains the interface of ACT-MS and methods to load a user data set into the visicon of ACT-R.actr.py- Contains the dispatcher of ACT-R version 7.12., which is necessary to form a connection between python and ACT-R (seehttp://act-r.psy.cmu.edu/).ExampleRUN-metamodel.pyEF-submodel-left.lispEF-metamodel.lispTODOPossible additional feature to add:Add more dynamic and additional possibilites to save simulation parametersAdd more possibilities to exchange parametersAdd debugging supportDeveloping pyactmsTo install pyactcv along with the tools to develop and run tests please run the following in your virtualenv:$pipinstall-e.[dev]Bibliography[1]new paper
Package: pyactor
PyActor is a python actor middleware for an object oriented architecture
constructed with the idea of getting two remote actors
to quickly communicate in a very simple, lightweight and minimalistic way.It supports two versions:ThreadingGevent green threadsIt also includes communication between machines using XMLRPC and a second version
that uses RabbitMQ message system in a transparent way.InstallationInstall using:python setup.py installor:pip install pyactorCheck that works executing the examples that you can find by cloningthe repository:cd examples
python sample1.py
...Check also the docs for a tutorial:Commits are build and tested automatically atTravis-CI.See code coverage atcodecov.ioorcoveralls.io.First stepsThis library is implemented using two types of concurrence:'thread': classic threads'green_thread': GeventGreen threads give a performance almost twice better.You will need to specify which one you are going to use at the beginning of your
script withset_context('TYPE'). Where type is one of the two keywords
above.Then, first of all, aHostis needed in order to create some actors.
Use it to spawn actors by giving the class type of the actor to create
and one string that will identify it among the host. See example:h = create_host()
actor1 = h.spawn('id1', MyClass)The class of an actor must have defined its methods in the _tell and _ask sets
so they can be called through the proxy. In the _tell set will be named those
methods meant to be asynchronous and in the _ask set, the synchronous ones.
In this example we have a classMyClasswith a sync methodask_me()and an
async methodtell_me():class MyClass:
    _tell = {'tell_me'}
    _ask = {'ask_me'}
    def tell_me(self, msg):
        print(msg)
    def ask_me(self):
        return "hello back"As you can see, the async method receives a message and simply prints it while
the sync method returns a result. You can now call this methods from your main
code:actor1.tell_me("Hello")
print(actor1.ask_me())Remote connectionsUnlike other library solutions, PyActor supports remote communication between
various machines by only giving an IP to the host. For example:host = create_host('http://127.0.0.1:1277/')And this host is online, so the other machine only needs to lookup for it:host = create_host('http://127.0.0.1:1679')
remote_host = host.lookup_url('http://127.0.0.1:1277/', Host)Or directly get one of its actors:c = host.lookup_url('http://127.0.0.1:1277/id1', 'MyClass', 'module')TutorialPyActor has many examples and a tutorial explaining all its features.
This examples can be found in the'pyactor/examples'directory of the project
(github).
They are also explained in the documentation as a tutorial, hosted atreadthedocs.org.
Package: pyActuarialValue
pyActuarialValue is an open source implementation of theActuarial
Value
calculatordeveloped the Department of Health and Human Services (HHS) for
determining the relative amount of claims paid a health plan.pyActuarialValue is in early stages of development. Many plan types are
not supported but the goal is to support the complete calculator and
offer additional support for alternate actuarial value statements.InstallBefore running the calculator runseed_datato load the actuarial
value(AV) data.UsageThe core actuarial value function takes a representation of the health
plan. This representation can be created using directly from or through
a JSON representation. Details of the JSON representation can be found
in the wiki for this repo.It is also possible to run the calculator directly from the command
line. To run the calculator from the command line simply typeav {health_plan_json}.ContributingThe calculator is built in an incremental fashion to be used as quickly
as possible. If you would like a specific set of benefits to be included
in the calculator or have found an error in the calculator please open
an issue.If you are planning on implementing a set of benefits in the calculator,
please open an issue as well so that other developers know that those
sets of benefits will be implemented.Please rebase and squash all commits into a single commit before
submitting a pull request.
Package: pyactup
PyACTUp is a lightweight Python implementation of a subset of the
ACT-R cognitive architecture’s Declarative Memory, suitable for
incorporating into other Python models and applications. Its design
is inspired by the ACT-UP cognitive modeling toolbox.There isonline documentation of PyACTUp,
and thesourcesare on GitHub.The latest version of PyACTUp can be download and installed from PyPi with pip:pip install pyactupUse of a virtual environment for Python, such as venv or Anaconda is recommended.PyACTUp requires Python version 3.8 or later.PyACTUp is released under the following MIT style license:Copyright (c) 2018-2024 Carnegie Mellon UniversityPermission 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.
Package: pyacunetix
Acunetix APICreate Acunetixacu=Acunetix(username,password,url,False)print("Is logged?:{}".format(acu.is_logged()))Get targetpprint(acu.get_targets())PoCtarget="42e9892c-3ce0-4cdb-808e-3d9811dd774f"if(target):print("Get target:{}".format(acu.get_target(target)))scan=acu.get_last_scan_from_target(target)print("Get scan :{}".format(acu.get_scan(scan)))print("Get session id :{}".format(acu.get_session_id_from_scan(scan)))session_id=acu.get_session_id_from_scan(scan)#pprint("Get results from scan: {} ".format(acu.get_results(scan,session_id)) )results=acu.get_results(scan,session_id)foriinresults["vulnerabilities"]:print("Result:{}".format(i))print(i["vuln_id"])pprint("Vuln:{}".format(acu.get_vulnerability_from_scan(scan,session_id,i["vuln_id"])))
Package: pyacvd
This module takes a surface mesh and returns a uniformly meshed surface using voronoi clustering.  This approach is loosely based on research by S. Valette, and J. M. Chassery inACVD.InstallationInstallation is straightforward using pip:$ pip install pyacvdExampleThis example remeshes a non-uniform quad mesh into a uniform triangular mesh.frompyvistaimportexamplesimportpyacvd# download cow meshcow=examples.download_cow()# plot original meshcow.plot(show_edges=True,color='w')clus=pyacvd.Clustering(cow)# mesh is not dense enough for uniform remeshingclus.subdivide(3)clus.cluster(20000)# plot clustered cow meshclus.plot()# remeshremesh=clus.create_mesh()# plot uniformly remeshed cowremesh.plot(color='w',show_edges=True)
Package: pyadaaah
Pyadaaah expands Python by an automatic, dynamic, runtime type and range checking mechanism. For example the linevardef int exampleVar = 0 in [0..5] with rw, check(strict)would create a 'variable' exampleVar of type integer and range 0..5. This means, that assignments alike:exampleVar = 1.234resp.exampleVar = 6would, after that, lead to a type mismatch resp. range mismatch exception. The former mechanism obviously resembles static types - as can be found in programming languages alike C and C++. Whereas the latter mechanism obviously resembles automatic range checking - as can be found in programming languages alike Ada.But pyadaaah goes far beyond that. Beneath type and range checking, pyadaaah e.g. also provides cython types, signals (!), semi-automatic documentation means and a python2 to python3 compatibility layer.Pyadaaah is a pure python library (just a single '.py'-file) compatible with Python2 as well as Python3. It's license allows you to use it free of charge (please read the license text for details - it is quite short!)Further infomations and links can be found on my homepage (see the link on the left hand).
Package: pyadalight
pyAdalightInstallation$pipinstallpyadalightUsage$pyadalight--help
Usage:pyadalight[OPTIONS]Options:-hl,--h-led-countINTEGERHorizontalLEDcount.-vl,--v-led-countINTEGERVerticalLEDcount.-p,--portTEXTSerialport.-m,--monitorINTEGERMonitorindex.--list-monitorsShowsmonitorslistandexits.--list-portsShowsportslistandexits.--helpShowthismessageandexit.LicenseThe source is released under MIT-License (seehttps://opensource.org/licenses/MIT).
Package: py-adapter
py-adapterRound-trip serialization/deserialization of any Python object to/from any serialization format including Avro and JSON.:blue_book: Documentation:https://py-adapter.readthedocs.ioInstallingpython-mpipinstallpy-adapterDevelopingTo setup a scratch/development virtual environment (under.venv/), first installTox.
Then run:tox-edevThepy-adapterpackage is installed ineditable modeinside the.venv/environment.Run tests by simply callingtox.Install code quality Git hooks usingpre-commit install --install-hooks.Terms & ConditionsCopyright 2023 J.P. Morgan Chase & Co.Licensed 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.ContributingSeeCONTRIBUTING.md
Package: pyADAqsar
pyADApyADA (Python Applicability Domain Analyzer) is a cheminformatics package to perform Applicability Domain of molecular fingerprints based in similarity calculation.
In this case, the calculation of the Applicability Domain consists of a scan of similarities of the structures
present in the test set in relation to the training set, the best similarity threshold is the one with the lowest
error and also the lowest number of molecules with similarity below the threshold.
A notebook file with an example of using this package is present in the directory 'example/example_of_use.ipynb'Dependenciesnumpypandastqdmscikit-learnTested in python3.6 and python3.8InstallVia pippip3 install pyADAqsarVia githubgit clone https://github.com/jeffrichardchemistry/pyADA
cd pyADA
python3 setup.py installHow to useThis package has three classes: Smetrics (perform some statistical parameters like Q2ext R2ext etc), Similarity (realize similarity calculations based in differents metrics ) and ApplicabilityDomain (run a scan of AD with differents thresholds). The line code bellow import all classes.from pyADA import Smetrics, Similarity, ApplicabilityDomainA file containing a jupyter-notebook with a few examples of use is in 'example' folder.
For more information about documentation run the help function of classes.help(Smetrics)
help(Similarity)
help(ApplicabilityDomain)
Package: pyad_auth
pyad_authSimple Python library to verify a user’s credentials against Active DirectoryRequirementsPython >= 2ldap3Installationpip install pyad_authUsageInclude pyad_auth in your projectUse pyad_auth.connect() to connect to the server:try:
    server = pyad_auth.connect("myip", port)
except Exception as e:
    # handle exceptionUse pyad_auth.auth() to verify if the user is in Active Directory:try:
    authenticated = pyad_auth.auth(server, "username", "password")
except Exception as e:
    # handle exception