Saravanan666/pypi-org huggingface dataset:
Package: alfpy
alfpyalfpy is a bionformatics Python package that provides alignment-free framework
to compare biological sequences (DNA/RNA/protein) and infers their
phylogenetic relationships.alfpy also contains Python scripts with user-friendly command-line interfaces
that let you compare unaligned FASTA sequences with more than 40 distance methods.Latest source codeThe official source code repository is at:https://github.com/aziele/alfpyWeb sitesalfpy is also available as a web app:http://www.combio.pl/alfreeRequirementsPython (https://www.python.org/) version 2.7 or >= 3.3NumPy (http://www.numpy.org/).InstallationOption 1: Get the latest official versionInstall the latest official version withpipsudo pip install alfpyIf you are not allowed to usesudo, install alfpy as user:sudo pip install --user alfpyOption 2: Get the latest development versionGet it using this shell command, which requires Git:git clone https://github.com/aziele/alfpy.gitIf you don’t feel like using git, just download the package manually as agzipped tarball.Unpack the zip package, go to the directory and run the installation:cd alfpy
python setup.py installor:python setup.py install --userAlfpy usageThe examples of using Alfpy are available at:http://www.combio.pl/alfree/download/.TestingTo run tests, go to the alfpy source code directory and type:python -m unittest discoverIf you want to test a specific file (e.g.test_word_distance.py), type:python -m unittest tests.test_word_distanceContactDrop us any feedback at:bioinfo@amu.edu.plor on twitter@a_zielezinski.Licensealfpy is under the MIT license; seeLICENSE.txt. Distribution,
modification and redistribution, incorporation into other software,
and pretty much everything else is allowed.
Package: alfred3-dbtools
alfred3_dbtoolsThis module provides additional tools for working with databases in the context of alfred3 experiments (seealfred3 on GitHub).Installationpipinstallalfred3_dbtoolsUsageTo import the tools for working with mongodb, include this statement at the beginning of your script:fromalfred3_dbtoolsimportmongotoolsYou can then access the classes provided in the module:mongotools.MongoDBConnectorcan be used to establish an independent connection to an instance ofpymongo.MongoClient.Access to the client is provided viamongotools.MongoDBConnector.db. This will return either a database instance or, if a specific collection was given during initialisation, that collection instance.Seehelp(mongotools.MongoDBConnector)for details.mongotools.ExpMongoDBConnectorcan be used to establish a connection to an experiments' MongoDBs.The constructor takes one parameter:experiment, which needs to be an alfred experiment. Seehelp(mongotools.ExpMongoDBConnector)for details.mongotools.ExpMongoDBConnector.dbwill return the MongoDBcollectionof theMongoSavingAgentwith the lowest activation level (i.e. the primaryMongoSavingAgent). It will raise aValueError, if the lowest activation level is occupied by two or moreMongoSavingAgents.mongotools.ExpMongoDBConnector.list_agentswill return a list of allMongoSavingAgents added to the experiment.Your experiment needs to have at leastone MongoSavingAgentfor this class to work.Refer to thepymongo documentationfor further details on how to interact with the clients.
Package: alfred3-interact
alfred3-interact: Interactive web-experiments in alfred3Alfred3-interact is a plugin foralfred3.
It allows for the creation of interactive web experiments, predominantly
in the social sciences. As prerequisites,
you need to havePython 3.7or newer andalfred3 v2.2.0or newer installed.Installation$ pip3 install alfred3_interactDocumentationDocumentation for alfred3_interact is available here:Link to docsQuick exampleBelow is an examplescript.pyfor creating an experiment with an
asynchronous exchange of data between participants matching:Initialize a group spec and thealfred3_interact.MatchMakerduring experiment setupUse aalfred3_interact.WaitingPagefor matchmaking inside itswait_forhook method.Find a group viaMatchMaker.matchand bind it to the
experiment plugins object.Now the group object is available in sections, pages, and elements
through the experiment session object. You can use it to access data
from other participants in the same group.# script.pyimportalfred3asalimportalfred3_interactasaliexp=al.Experiment()@exp.setupdefsetup(exp):spec=ali.SequentialSpec("role1","role2",nslots=10,name="mygroup")exp.plugins.mm=ali.MatchMaker(spec,exp=exp)@exp.memberclassMatch(ali.WaitingPage):defwait_for(self):group=self.exp.plugins.mm.match()self.exp.plugins.group=groupreturnTrue@exp.memberclassSuccess(al.Page):title="Match successful"defon_exp_access(self):group=self.exp.plugins.grouptxt=f"You have successfully matched to role:{group.me.role}"self+=al.Text(txt,align="center")if__name__=="__main__":exp.run()The demo experiment can be started by executing the following command
from the experiment directory (i.e. the directory in which you placed
thescript.py):$ alfred3 runCitationAlfred3-interact was developed for research at the department for
economic and social psychology, Georg-August-University Göttingen.If you are publishing research conducted using alfred3, the
following citation is required:Brachem, J. & Treffenstädt, C. (2021). Alfred3-interact - Interactive web experiments in alfred3. (Version x.x.x). Göttingen,
Germany:https://doi.org/10.5281/zenodo.1437219
Package: alfred3-reaction-times
alfred-reaction-timesAlfred3 library for measurement of reaction timesInstallationPlease note, that the base package alfred3 must also be installed.$ pip install alfred3Afterwards, you can install alfred3_reaction_times:$ pip install alfred3-reaction-timesA "Hello world" experimentimportalfred3asalimportalfred3_reaction_timesasartexp=al.Experiment()exp+=al.Page('Reacting to "Hello World"',name="hello_world")exp.hello_world+=al.Text('Please press any key when you see "Hello World')exp.hello_world+=art.ReactionTimes(art.Trial(art.Fixation(element=al.Text("X"),# any alfred3 element to be shownduration=5# display duration in seconds),art.Stimulus(al.Text("Hello world"),# any alfred3 element to be shownart.Reaction("any")# definition of the keys that are considered as the proper reaction)))In this example, an "X" will be shown as a fixation stimulus, followed by the text
"Hello World" after 5 secondsOn further information on how to write and run an alfred3 experiment,
please read thealfred3 documentation
Package: alfred-cli
AlfredAlfred is an extensible automation tool designed tostreamline repository operations. It allows you various commands as continuous integration, runner, build commands ...You'll craft advanced commands harnessingthe strengths of both worlds: shell and Python.Demointroductory videoQuick-startYou will generate commands to launch of the linter and unit tests process.$alfred--newpylintsrc/myapp$alfred--newpytesttests/unitalfredUsage: alfred [OPTIONS] COMMAND [ARGS]...

  alfred is an extensible automation tool designed to streamline repository
  operations.

Options:
  -d, --debug    display debug information like command runned and working
                 directory
  -v, --version  display the version of alfred
  --new          open a wizard to generate a new command
  -c, --check    check the command integrity
  --completion   display instructions to enable completion for your shell
  --help         Show this message and exit.

Commands:
  lint                run linter on codebase
  tests               run unit tests on codebaseLinksDocumentation :https://alfred-cli.readthedocs.io/en/latestPyPI Release :https://pypi.org/project/alfred-cliSource code:https://github.com/FabienArcellier/alfred-cliChat:https://discord.gg/nMn9YPRGSYRelatedalfredexists thanks to this 2 amazing open source projects.clickplumbumLicenseMIT LicenseCopyright (c) 2021-2023 Fabien ArcellierPermission 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: alfred-genie
Genie for AlfredGitHub
licenseTwitter FollowUsing from AlfredInstallAlfred Genie.alfredworkflowin Alfred and use thegeniecommand to use any available function.Using from Command line$ pip install alfred-genieThen the following commands will be available$ alfred-genie
Usage: alfred-genie [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  base64-decode
  base64-encode
  commands # ignore this as this is only used from Alfred
  format-json
  minify-jsonContributingPull requests are welcome. For major changes, please open an issue first
to discuss what you would like to change.You’ll need a working version ofPython3to run these scripts.Create and use new virtual envpython3 -m venv venv
source venv/bin/activateInstall required dependencies$ pip install -r requirements.txtRun locally$ python local_main.py ...Creating Alfred WorkflowFor publishing it in workflow, we need to perform following additional
steps[ ] Open workflow file in Alfred[ ] Open workflow directory in Terminal[ ] Apply any changes from this directory to workflow directory[ ] Install dependencies in workflow directorypip install--target=.click[ ] Export workflow and publish to GithubPublishing Updates to PyPi$makepackageEnter the username and password for pypi.org repo when promptedLicenseMIT
Package: alfred-installer
AlfredA script to install all your favourite applications and perform the most
common tasks automatically in Debian, Ubuntu and their derivative distros.Alfred can install the most common applications and packages for you, while you
take a nap or walk the dog. Just tell Alfred what you want him to do for you and
he will take care of it in no time. This is perfect for Linux beginners and lazy
users like me, specially for those times when you have just installed the system.Python script usageOpen a terminal, paste the line below and then press enter. You will have to type your password.wgethttps://raw.githubusercontent.com/derkomai/alfred/master/alfred.py&&python3alfred.pyBash script usage (now obsolete and discontinued)The graphical, beginner-friendly wayDownload Alfred inthis link: right click on the link, selectsave link asand click OK, ensuring that the file name is justalfred.shwithout any other extensions.Open your downloads folder. You should see a file namedalfred.sh.Right clickalfred.shfile, selectPropertiesand open the tab namedPermissionsin the dialog.Now, depending on your system, you should see something likeAllow executing file as a programor a table where you can giveExecutionpermissions for the file owner. Ensure this is activated and click OK.If you are using Ubuntu or at least the Nautilus file browser, ensure thatEdit > Preferences > Behaviour > Executable text files > Run executable text files when they are openedoption is activated.Openalfred.shby clicking on it.You will be asked for your password. Type it and click OK.Select the tasks you want to perform and click OK. Wait for them to complete. That's it.The easy command line wayOpen a terminal, paste the line below and then press enter. You will have to type your password.sudoapt-yinstallgit&&gitclonehttps://github.com/derkomai/alfred&&sudo./alfred/alfred.shDonationIf you find Alfred useful and it has saved you some time or trouble, you can support it by making a small donation through Paypal or cryptocurrencies.Paypal:Bitcoin address:3F888TKJvWvkRmGVDyeCFAoBbFnLoYsrYPBitcoin Cash address:1LfY7Mjh3z11ek1A2exKm3JdXw8VheNHdUEthereum/ERC20 address:0x0Ddc94917100387909cb6141c2e7e453bd31D3f7Litecoin address:MVXhiKnsMTiZYWfzdQ9BdJT8wDpSNrBme1XRP address:rFeeJw6rsoeSmu9BAL12gHSaMwtvFQgifStellar address:GBON6KJYAQMRYTMEOSZQI22MOGZK7FWKDLAIWXRLZSG2XEZ6RG73PUGTNeo address:AGehUh61V2mjmhwsk3sGus5hEVYQZxexZa
Package: alfredo
Alfredo - Born to serve!************************Alfredo is a simple, extensible gtalk bot. It's capable of doing any kind of tasks, implemented as separated commands.Here is a typical session: ::you: inv some textalfredo: called inv some text -> txet emosImplementing a new command**************************Commands are implemented as Plugins (more at plugnplay <https://github.com/daltonmatos/plugnplay>). Just create a new class:from alfredo import Plugin, ICommandclass SomeCommand(Plugin):implements = [ICommand]def help(self):return ('short help', 'long help')def name(self):return 'mycommand'def match_name(self, command):return 'mycommand' == commanddef run(self, user, *args)# process some logicreturn resultIn this case we create a new command named 'mycommand'. If we send this message to alfredo:mycommand p1 p2 p3the ``run()`` method would be called like this: ``run('user@domain.com', 'p1', 'p2', 'p3')``. This method must return a string, that will be sent back to the original user.How to use it*************To start talking to a running instance of alfredo just add ``alfredo@daltonmatos.com`` to your gtalk conacts list and you are done!Or try out your own commands from the example code.Dependencies************Alfredo's core components only needs:* plugnplay - https://github.com/daltonmatos/plugnplay* xmpppy - http://xmpppy.sourceforge.net/The included commands needs:* BeautifulSoup - http://www.crummy.com/software/BeautifulSoup/* requests - https://github.com/kennethreitz/requests* simplejson - http://code.google.com/p/simplejson/You can even run the requirements file to get up your environment::pip install -r requirements.txt--Dalton barretodaltonmatos@gmail.com
Package: alfredo-python
Idiomatic way for Python developers to integrate with Alfredo services.Contents1Installation2Command Line Interface Usage3Python Software Development Kit4Development1InstallationOn most systems, you can usepip(recommended):# Make sure we have an up-to-date version of pip and setuptools:pipinstall--upgradepipsetuptoolspipinstallalfredo-pythonBoth Python 2 and 3 are supported.2Command Line Interface UsageThe main command to interact with Alfredo stack isalfredo.Input is expected to be in YAML format, and also the output is serialized in that way.You can setRUOTE_ROOTand/orVIRGO_ROOTenv vars to point the CLI and the SDK to your desired installation of the Alfredo stack.After that, you can executealfredoto get the usage help.You can also executealfredo-helpto get an updated list of the options you have, with examples.3Python Software Development KitThe main module you need to import to interact with the Alfredo stack isalfredo.The main functions of the module are theruoteandvirgoones, to get the client object to further interact with respective services.You can usealfredo.ruote()to get annonymous access to the open endpoints in Ruote. The same applies forvirgo.For instance, you can use the annonymous access to get a token given an email and a password.Please feel free of using the Python console to get used to the SDK prior to using it in real Python code.>>>alfredo.ruote().sso.token_by_email.create(email='alice@example.com',password='*******')400-BadRequestnon_field_errors:-Unabletologinwithprovidedcredentials.>>>alfredo.ruote().sso.token_by_email.create(email='alice@example.com',password='********')200-OKtoken:b1cff2aab075744ddda6b00805617f561e940107You can usealfredo.ruote(token='b1cff2aab075744ddda6b00805617f561e940107')to get an authenticated client against Ruote.>>>alfredo.ruote(token='b1bff2aab075744ddda6b00805617f561e940107')200-OKAWSclusters:http://api.teamjamon.com/AWSclusters/apps:http://api.teamjamon.com/apps/clusters:http://api.teamjamon.com/clusters/datasets:http://api.teamjamon.com/datasets/files:http://api.teamjamon.com/files/jobs:http://api.teamjamon.com/jobs/queues:http://api.teamjamon.com/queues/users:http://api.teamjamon.com/users/vdcs:http://api.teamjamon.com/vdcs/Most of the functions mimic the url structure of the http API, and receives named parameters as input.Please refer to the Alfredo API documentation for further details.4DevelopmentYou can create your fork of the repo before making any change.Never forget to install the requirements first if you are using an isolated virtualenv:pip install-rrequirements.txtAnd to include the test requirements if you are planning to pass the tests locallypip install-rrequirements-test.txtYou can run the tests usingnosetests--with-coverage--cover-package=alfredo--stopCurrently, the main branch isdevelopbecause the code is still in beta. You can make PRs againstdevelop.
Package: alfreds
Alfreds CLI ToolAlfreds (www.alfreds.ai) is the LLM platform for data teams. It enables data teams to create LLM agents that can be used
in different stages of data workflows.
Alfreds command-line tool allows data teams to install alfreds platform on their local machines and perform various tasks.PrerequisitesPython 3.6 or higherDockerLinux or macOSInstallationTo install alfreds, run the following command:pip install alfredsUsageAlfreds can perform the following tasks:Initialize alfreds:alfreds init --agent_path {agent_absolute_path} --working_dir {working_dir_absolute_path} --seed_dir {seeds_absolute_path(optional)}This command initializes alfreds with the specified agent, working directory, and seeds (optional).Example:alfreds init --agent_path /Users/subu/alfreds/agent --working_dir /Users/subu/alfreds/working_dir --seed_dir /Users/subu/alfreds/seedsUpdate the agent:alfreds update_agent {agent_absolute_path}This command updates the agent with the specified absolute path.Example:alfreds update_agent /Users/subu/alfreds/agentUpdate the working directory:alfreds update_working_dir {working_dir_absolute_path}This command updates the working directory with the specified absolute path.Seed the application:alfreds seed {seed dir/csv file absolute path}This command seeds the application with the specified seed directory or CSV file.Stop alfreds:alfreds stopThis command stops the alfreds application.Start alfreds:alfreds startThis command starts the alfreds application.Refresh alfreds:alfreds refreshThis command refreshes the alfreds application.Alfreds Help:alfreds --helpThis command displays the help menu for alfreds.Please note that you need to provide the absolute paths for the agent, working directory, and seeds when using the respective commands.If you have any questions or need further assistance, please refer to the alfreds documentation or contact our support team.
Package: alfREST
A ligthweight python library based on the Alfresco RESTful web services.Sample usage:from alfREST import RESTHelper
path = "/Sites/mysite/documentLibrary/test"

# login
rh = RESTHelper()
rh.login(login, password, host, port)

# createDocument (sio could be a file object...)
from StringIO import StringIO
sio = StringIO()
sio.write("Well, that's all folks.")
sio.seek(0)
sio.name = "test.txt"
tkns = path.split("/")
siteId = tkns[2]
containerId = tkns[3]
uploadDirectory = "/".join(tkns[4:])
idObject = rh.fileUpload(sio, siteId, containerId, "/%s" % uploadDirectory)
sio.close()

# get properties
props = rh.getProperties("%s/test.txt" % path)
assert props["cmis:createdBy"] == login

# get content
content = rh.getContent("%s/test.txt" % path)
assert content == "Well, that's all folks."

# add a tag to the document
rh.addTag("workspace", "SpacesStore", idObject, "tag_test")
assert "tag_test" in rh.getNodeTags("workspace", "SpacesStore", idObject)

# list document in folder
children = rh.getChildren(path)
assert children[0]["cmis:name"] == "test.txt"

# create a group and apply a  policy to the test folder
rh.addRootGroup(u"GROUP_TEST")
acl = {}
acl[u'GROUP_TEST'] = [([u"{http://www.alfresco.org/model/content/1.0}cmobject.Consumer",], True),]
rh.applyACL(path, acl)

# create a new user, insert the user in the group
rh.addPerson("supermario", "mario", "super", "supermario@nintendo.com", "imsuper")
rh.addGroupOrUserToGroup(u"supermario", u"GROUP_TEST")

# some check
users = rh.listChildAuthorities(u"GROUP_TEST")
assert len(users) == 1
assert users[0]['fullName'] == "supermario"

# restore initial status
rh.removeAuthorityFromGroup(u"supermario", u"GROUP_TEST")
rh.deletePerson("supermario")
acl = {}
rh.applyACL(path, acl)
rh.deleteRootGroup(u"GROUP_TEST")

# remove tag from the file object
rh.deleteTag("workspace", "SpacesStore", idObject, "tag_test")
assert "tag_test" not in rh.getNodeTags("workspace", "SpacesStore", idObject)

# delete the file object
rh.deleteObject(idObject)

# logout
rh.logout()Changelogs 0.9.3addTagdeleteTagChangelogs 0.9.2c (bugfix: upload binary files works)createFoldergetNodeTags (get all the tags for a node)Changelogs 0.9.1upload (upload file content and meta-data into repository)delete file (delete the specified object)getChildren (gets the list of child objects contained in the specified folder)getContent (gets the content stream for the specified document)getProperties (gets the properties for the object)Road to 1.0Create / Move a Folder or Document (createDocument, createFolder, createPolicy, moveObject)Write Content (setContent)Delete Content (deleteContent)Get Content (getContent)Get Folder Children (getChildren)Road to 1.1Get Checked Out Documents (getCheckedOutDocs)Checkout Document (checkOut)Cancel Checkout (cancelCheckout)Checkin Private Working Copy (checkin)ContactsFor more info and requests: tiziano [at] axiastudio.it
Package: alfrodull
AlfrodullAlfrodull is a utility that controls lights based on the a computers events.The lights can be turned off when the computer sleepd, and turn on when the computer wakes up. The original use case was to attach an led strip behind the monitor that turn on and off as the display does. But much more can be doen as additional events can easily be added. For example blinking the lights when notifications are received or tracking CPU usage and warning when it passes a threshold.Right now the only supported devices are those fromblinksticks. More can be added if requested and I can get ahold of them.Alfrodull only works on Linux right now as all of the events uses DBUS notifications to react to events. Support for Windows could be added in the future but would require some other notification service.InstallpipinstallalfrodullUsageSimply start alfrodull and pass a configuration file path as input.alfrodullconfig.ymlAlfrodull could for example be started in xinit or i3wm config.ConfigurationAlfrodull is configured with a file, this is where the event, animation and, color are specified. Colors are defined as hex values ex.#ff00ff, the values will be checked when the program is started and throw an exception if they can't be parsed. Passing a null value to the color is parsed as turning off the lights. Below are the currently supported events and animations that can be used.EventDescriptionInitAfter the applicationn is first runShutdownBefore the computer turns offSleepBefore the computer goes to sleepWakeupAfter the computer wakes upEffectDescriptionFadeFades from the current color or if the color is null turn off.Outside InStarts from the outside and changes light one by one to the inside.Inside OutOpposite of Outside In.device: blinkstick
events:
  - type: "Init"
    animation:
      type: "Fade"
      color: "#ffffff"
  - type: "Sleep"
    animation:
      type: "Inside Out"
      color: "#000000"
  - type: "Wakeup"
    animation:
      type: "Outside In"
      color: "#ffffff"LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.