Saravanan666/pypi-org huggingface dataset:
Package: agentforum
🏛 AgentForumAn asynchronous framework for building LLM-based multi-agent systems in Python, with a focus on:Message trees which highly resemble commits in git to facilitate backtracking.Messages are immutable and are
identified by hashes based on their content and their history (a hash of the previous message). A single hash
represents state of a conversation at a given point in time.Message promises and the possibility of token streaming.MessagePromiseobjects are returned before the
messages are fully generated. Token streaming is supported regardless of the number of nested levels of agents.NOTE: While this framework is designed with LLMs in mind, it can be used with any kind of agents.🧩 FeaturesMessage forwarding.Messages can be forwarded to become a part of different message branches or
trees (much like it is done in messaging apps for humans).💡 PhilosophyAgents run as concurrently as possible.When an agent is called with.call()or.quick_call()a task is
scheduled andAgentCallorAsyncMessageSequenceobjects are returned immediately. The actual processing will
happen upon a task switch.Stateless agents are encouraged.This is not a hard requirement, but ideally the agents should produce the same
output when they are given the same input (the same sequence of messages from a message branch).🔧 Implementation detailsThis framework supportsPython 3.9 or higherand usesasynciounder the hood.🌱 Future plansMessage replies.Technically this will be very similar to message forwarding. The difference will mostly be
semantic (in the spirit of mimicking messaging apps for humans).Exceptions as part of the message tree.In the future, exceptions raised by agents will be represented as a
special type of messages and will be part of the message branches those agents were on when they were raised.Optional caching of agent responses (enabled by default).When the same sequence of messages is sent to an agent,
the framework will respond with the same sequence of response messages without actually calling the agent.Cancellation of agent execution.In the future, it will be possible to cancel the execution of agents before
they finish.⚠️ NOTE: These plans are tentative and may change in the future. ⚠️
Package: agentfud-art-engine
agentfud-art-engineArt engine which helps you to generate thousands of beautiful images for the NFT market.FeaturesConfigurable layersConfigurable rarity weightsInformation about your projectMetadata and image generation based on pre-generated DNAsExcluding traits from metadataInstallationviapipAll the artengine projects could be in a single directorymkdirartengine_projectscdartengine_projectsCreating and activating virtual environmentvirtualenvenvsource./env/bin/activateInstall agentfud-art-enginepipinstallagentfud-art-engineCreate first project in my_project directoryartengineinitmy_projectEnter into the directory, start configure and buildcdmy_projectNow we can editinstance_config.pyIf you want to fully test it, removelayersfolder, then clone a prepared layers folder like thisrm-rflayersgitclonegit@github.com:AgentFUD/layers.gitRunartengine info, then follow the tutorials.UsageCreate your own layers.Editinstance_config.py, set up your layers, DNA generation type, etc.Generate rarity configuration file withartengineraritygenerateconfigEdit rarity-config.json as you like. Please keep in mind artengine info will tell you the maximum possible combinations so do not try generate more than you possibly could.Generate DNA database.artenginedna--collection_size30-retries10Check generated rarities withartengineraritycheckBake your imagesartenginebakeboth/metadata/images[--clean-up]Development installgit clone https://github.com/AgentFUDagentfud-art-engine.git

cd agentfud-art-engine

virtualenv env

source ./env/bin/activate

pip install --editable .type artengine, you should see something very similar(env) agentfud@Legion-Y540:/tmp/agentfud-art-engine$ artengine
Usage: artengine [OPTIONS] COMMAND [ARGS]...

  Welcome to Agent FUD ArtEngine! An all-in-one cli tool for NFT artists!

Options:
  --help  Show this message and exit.

Commands:
  bake          Bakes images and metadata files
  info          Gathers and prints out information about your project
  init          Initializes a new Art Engine project
  rarityconfig  Generates rarity config json file
  run           Runs any python script
Package: agent-harness
Agent HarnessAI Maintainer Agent Harness for our benchmarking and Marketplace API and platformFree software: MIT licenseDocumentation:https://agent-harness.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2023-08-13)First release on PyPI.0.1.8 (2023-09-09)Preparations for Open Source ReleaseSimplification of interface with aider
Package: agent-Job-scheduler
quick start>>> import agent
>>> a = agent.Agent()
>>> import  datetime
>>> options = {
... 'scheduler': 'interval',
... 'start_time': datetime.datetime.now(),
... 'interval': 1
... }
>>> @agent.create_job_decorator(options=options)
>>> def sample_job_every_5s():
...     print('I am running whiteout massage and name')
>>>
>>> a.start()
Package: agentk
"k"TLDR;Install the "k" by either doing:pip install agentk(Yes, ^^ it is written in python and your OS needs to have recent version 2 or 3)or copying it in some bin folder on your PATH and runningpip install -r requirements.txt"A person is smart. People are dumb, panicky, dangerous animals, and you know it." -- Agent K"AGENT" K is a complete minimalistic kubectl "doner"-wrapObviously, as a short-hand wrapper,kcan do everythingkubectlalready can, but it is (a) shorter and (b) adds few tricks like merging configs and switching contexts .. (k) feeds back to thekubectlcommand-line those args which it does not want to intercept or handle.UsageThe following is equivalent:kubectl get pods --all-namespaces
k get pods -A
k p -ASwitching contextArgument-free invocation prompts for context switch options between multiple cluster contexts found in~/.kube/config:kSwitching namespacesOne can change the default namespace on the currently active context (namespacekey in~/.kube/config) using either of two equivalent commands:kubectl config set-context $(kubectl config current-context) --namespace foo
k sn fooThe last command is akshortcut.Shortcuts to get resourcesYou can find the full list of shortcuts defined as the dictionary inside thekscript. In particular that would be:# resource
"ev": "event",
"ep": "endpoints",
"p": "pod",
"s": "service",
"v": "volume",
"n": "node",
"dp": "deployment",
"st": "statefulset",
"in": "ingress",
"ns": "namespace",At the end of the list there are one letter action-shortcuts:# actions
"c": "create",
"a": "apply",
"d": "delete",This means that the following is equivalent:kubectl apply -f <foo-k8s-manifest.yaml>
k a -f <foo-k8s-manifest.yaml>DevelopTo remind, you can dopip install -e .in order to utilize developer mode.Installation in the cloudIf you work withkubectlwithout a privileged or super-user access, for example inside a corporate network or in a cloud-shell (but you still have access to python), then your installation will look like:pip install --user agentkThis will install the script in your local$HOMEfolder.Don't forget to append your~/.bashrcor~/bash_profileor other shell-rc file with:export PATH="$HOME/.local/bin:$PATH"Command completionYou can put this into your.bashrcto get alias and auto completion forksimilar as forkubectl:source <(kubectl completion bash | sed s/kubectl/k/g)Similar works well forzsh.
Package: agentlabs
AgentlabsPython library for implementing agents onWeavelInstallationpipinstallagentlabsExample UsagefromagentlabsimportAgent,InputTypeagent=Agent()@agent.service(id=3,name="blog_post",description="Given a keyword as input, this service generates a SEO-optimized blog post",)@agent.service_input(name="keyword",display_name="키워드",description="The keyword for which the blog post should be generated",type=InputType.TEXT,options=["아로니아","아로니아 농장",],)@agent.service_input(name="post_length",display_name="글 길이",description="Desired length of the blog post",type=InputType.TEXT,placeholder="Medium",options=["Short","Medium","Long",],)asyncdefgenerate_blog(keyword:str):awaitagent.aupdate_status("Generating blog outline...")awaitagent.aupdate_status("Writing post...")awaitagent.aupdate_status("Searching for images...")awaitagent.aupdate_status("Adding images to post...")awaitagent.aupdate_status("Generating title...")return{"blog":"블로그",}if__name__=="__main__":agent.run(token="5f2593e7-1a10-492e-a9c1-e7521d400e2b")
Package: agentlib
This is a collection of base classes for the implementation of agents in Python.
The original purpose of this library is the execution of distributed simulations and controllers for energy systems, however it is not limited to any specific field.
To get started, please check out our examples.InstallationTo install the agentlib with minimal dependencies, run:pip install agentlibTo install with full dependencies (recommended), run:pip install agentlib[full]If you want to work on the agentlib, first clone it, go its directory and then install it in editable mode:pip install -e .[full]Optional DependenciesThe AgentLib has a number of optional dependencies, ranging from additional features to performance improvements:fmu: Support simulation of FMU models (https://fmi-standard.org/).scipy: Support simulation of linear state space models, based on scipy.mqtt: Support communication between agents through the mqtt protocol.plot: Installs matplotlib, allows to plot the result of examples.orjson: Faster json library, improves performance when using network communicators.fuzz: Improves error messages when providing wrong configurations.clonemap: Support the execution of agents and their communication throughclonemap. As clonemapy is not available through PYPI, please install it from source, or through the AgentLib'srequirements.txt.Referencing the AgentLibA publication regarding the AgentLib is currently in the work.
If you use the AgentLib in your work which you plan to publish, please check back at a later date for a reference.Copyright and licenseThis project is licensed under the BSD 3 Clause License - see theLICENSEfile for details.AcknowledgmentsWe gratefully acknowledge the financial support by Federal Ministry \ for Economic Affairs and Climate Action (BMWK), promotional reference 03ET1495A.
Package: agent-protocol
Agent Protocol - Python SDKReference implementation of the Agent Protocol in Python by the AI Engineers Foundation (AIEF). This SDK allows you to easily wrap your agent in a webserver compatible with the protocol - you only need to define the task and step handlers for your agent.Installationpipinstallagent-protocolThen add the following code to your agent:fromagent_protocolimportAgent,Step,Taskasyncdeftask_handler(task:Task)->None:# TODO: Create initial step(s) for the taskawaitAgent.db.create_step(task.task_id,...)asyncdefstep_handler(step:Step)->Step:# TODO: handle next stepifstep.name=="print":print(step.input)step.is_last=Truestep.output="Output from the agent"returnstepif__name__=="__main__":# Add the task handler and start the serverAgent.setup_agent(task_handler,step_handler).start()CustomizationDatabaseBy default, the SDK stores data in memory. You can customize the database by setting db to your own database object.Agent.db=your_databaseThe database object must implement the methods fromdb.py.RoutesYou can also add your own routes to the server. For example:fromagent_protocolimportAgent,routerfromfastapiimportAPIRoutermy_router=APIRouter()@my_router.get("/hello")asyncdefhello():return{"hello":"world"}my_router.include_router(router)task_handler=...step_handler=...Agent.setup_agent(task_handler,step_handler).start(router=my_router)TestingYou can test the compliance of your agent using the following script:URL=http://127.0.0.1:8000bash-c"$(curl-fsSLhttps://agentprotocol.ai/test.sh)"What this does is run a series of GET and POST requests against your agent to verify that it's compliant with the Agent Protocol.DocsYou can find more info and examples in thedocs.DevelopmentIf you want to use the agent_protocol package from the cloned repository, you should be able to use poetry to set it up, like below.gitclonegit@github.com:AI-Engineers-Foundation/agent-protocol.gitcdagent-protocol/sdk/python
poetryinstall
poetryrunpythonexamples/minimal.pyFeel free to openan issueif you run into any problems!
Package: agent-protocol-client
Agent Protocol - Python ClientInstallationpipinstallagent-protocol-clientGetting StartedIn your own code, to use this library to connect and interact with agent-protocol-client,
you can run the following:importtimeimportagent_protocol_clientfromagent_protocol_client.restimportApiExceptionfrompprintimportpprint# Defining the host is optional and defaults to http://0.0.0.0:8000# See configuration.py for a list of all supported configuration parameters.configuration=agent_protocol_client.Configuration(host="http://0.0.0.0:8000")# Enter a context with an instance of the API clientasyncwithagent_protocol_client.ApiClient(configuration)asapi_client:# Create an instance of the API classapi_instance=agent_protocol_client.AgentApi(api_client)task_request_body=agent_protocol_client.TaskRequestBody()# TaskRequestBody |  (optional)try:# Creates a task for the agent.api_response=awaitapi_instance.create_agent_task(task_request_body=task_request_body)print("The response of AgentApi->create_agent_task:\n")pprint(api_response)exceptApiExceptionase:print("Exception when calling AgentApi->create_agent_task:%s\n"%e)Documentation for API EndpointsAll URIs are relative tohttp://0.0.0.0:8000ClassMethodHTTP requestDescriptionAgentApicreate_agent_taskPOST/ap/v1/agent/tasksCreates a task for the agent.AgentApidownload_agent_task_artifactGET/ap/v1/agent/tasks/{task_id}/artifacts/{artifact_id}Download a specified artifact.AgentApiexecute_agent_task_stepPOST/ap/v1/agent/tasks/{task_id}/stepsExecute a step in the specified agent task.AgentApiget_agent_taskGET/ap/v1/agent/tasks/{task_id}Get details about a specified agent task.AgentApiget_agent_task_stepGET/ap/v1/agent/tasks/{task_id}/steps/{step_id}Get details about a specified task step.AgentApilist_agent_task_artifactsGET/ap/v1/agent/tasks/{task_id}/artifactsList all artifacts that have been created for the given task.AgentApilist_agent_task_stepsGET/ap/v1/agent/tasks/{task_id}/stepsList all steps for the specified task.AgentApilist_agent_tasksGET/ap/v1/agent/tasksList all tasks that have been created for the agent.AgentApiupload_agent_task_artifactsPOST/ap/v1/agent/tasks/{task_id}/artifactsUpload an artifact for the specified task.Documentation For ModelsArtifactGetAgentTask404ResponsePaginationStepStepRequestBodyTaskTaskArtifactsListResponseTaskListResponseTaskRequestBodyTaskStepsListResponse
Package: agentpy
AgentPy - Agent-based modeling in PythonAgentPy is an open-source library for the development and analysis of agent-based models in Python.
The framework integrates the tasks of model design, interactive simulations, numerical experiments,
and data analysis within a single environment. The package is optimized for interactive computing
withIPython,IPySimulate, andJupyter.Please cite this software as follows:Foramitti, J., (2021). AgentPy: A package for agent-based modeling in Python. 
Journal of Open Source Software, 6(62), 3065, https://doi.org/10.21105/joss.03065Installation:pip install agentpyDocumentation:https://agentpy.readthedocs.ioJOSS publication:https://doi.org/10.21105/joss.03065Discussion forum:https://github.com/JoelForamitti/agentpy/discussionsTutorials and examples:https://agentpy.readthedocs.io/en/latest/model_library.htmlComparison with other frameworks:https://agentpy.readthedocs.io/en/latest/comparison.html
Package: agent-reader
Agent ReaderIntelligent Reader for various kinds of media sources: web pages, Twitter threads, etc.Early alpha version. Please don't use it for anything serious.Supported media sourcesWeb pagesGitHub projectsArxiv papers annotationsOpen Access (CVPR)Twitter threadsReddit threadsYouTube videos (aspirational; it's beyond text summarization)Installationpipinstallagent-readerUsageLook at thedemoscript for the example of usage.
Package: agentrs
AgentPy-rsA Rust based implementation of the AgentPy library,
to speed up both development and runtime of agent-based models.PrerequisitesTo quickly start a new project, all that you need isNix(only the package manager, not the OS).To install, simply runsh nix-install.sh(this will also go through some extra setup steps for you).If you are on MacOS, please seehow to setup a linux-builder(and don't forget tonix run nixpkgs#darwin.linux-builderwhenever you build with Nix)User guideAssume that you have Nix installed, it's as easy as:mkdirmy-abmcdmy-abm
nixflakeinit-tgithub:Benni-Math/agentrsThen, you can start developing withnix develop, or open a Jupyter Notebook withnix run ., or build a Docker image for your model withnix build .#docker.
Package: agentscript
AgentscriptA programming language for AI agentsExplore the docs »View Demo·Report Bug·Request FeatureAgentscript is an isomorphic programming language for AI agents, it includes both a server-side interpreter and browser-based renderer.▶ On the server, agenscript directly interprets LMM outputs and executes actions in a streaming manner.▶ In the browser, agentscript renders LLM outputs in a rich manner and provides live updates.Server-side InterpreterThe server side interpreter is implemented inagentscript.rsand provides a Python interface. The interpreter is capable of executing actions in a streaming manner.InstallpipinstallagentscriptUsageExecute the translator tool from PythonfromagentscriptimportInterpreterfromopentoolimportTool,action# Create a fake translator toolclassTranslator(Tool):"""A fake translator tool"""@actiondeftranslate(self,text:str)->str:return"Hola"# Create the interpreter supplying our translator toolinterpreter=Interpreter(tools=[Translator()])# Parse the script, find the tool, and execute itinterpreter.execute("""We need to do translation <Invoke tool="Translator" action="translate" parameters={"text": "Hello"} />""")# Show the past invocations with the resultsprint(interpreter.invocations())Browser-based RendererInstallnpm i @agentsea/agentscriptUsageimportAgentscriptfrom"@agentsea/agentscript";(<Agentscripttext="I created this image for you <Image url='https://any.url' />"url="...">)ComponentsBoolean(<Agentscripttext="Does this work for you? <Boolean />">)Image(<Agentscripttext="I created this image for you <Image src='https://any.url' />"">)Invoke(<Agentscripttext='Lets check the weather <Invoke tool="Weather" action="get" parameters={"location": "Madrid"} />'>)DialectsThe above components are known as thecommondialect, but you can create your own dialects as wellRoadmapProgramable LLMsGive agentscript the ability to program an LLM. Here we load a LoRA into a PEFT compatible LLMinterpreter.execute("I need to load the weather LoRA <Load lora='weather' />")Browser componentsSelect OneSelect AnyVideoPlanReferencesImage with bounding boxTaskMarkdownCode blocksDevelopTo testmaketestTo publishmakepublish
Package: agentscript-pyo3
agentscript.pyo3Python bindings for the Rust agentscript interpreter.BindsAgentscript.rstoAgentscript.Installpipinstallagentscript_pyo3Usagefromagentscript_pyo3importParserparser=Parser()message='We need to do translation <Invoke tool="Translator" action="translate" parameters={"text": "Hello", "options": {"from": "en", "to": "es"}} /> with some tailing text'parser.parse(message)parsed_data=parser.get_parsed_data()print(parsed_data)DevelopTo testpython-mvenv.venvsource.venv/bin/activate
maturindevelop
maketestTo publishmaturinpublish
Package: agentserver
agentserverA server that allows you to control and monitorsupervisoragentinstances.CommandsagentserveragentserveradminagentserverechoNoteThis project is under heavy development. It currently requiresDruid,PlyQL, andKafkato run.TODOsDruid and Kafka as optional dependencies.Documentation.A lot of the code relies heavily on integration tests for the HTTP and websocket APIs. Add unit tests.Expand code coverage.User friendly way to create and initialize databases fromagentserveradmin.
Package: agentspeak
A Python-based interpreter for the agent-oriented programming language JASON.python-agentspeakis a Python-based interpreter for the agent-oriented programming language JASON. This library makes it easy to create and manage intelligent agents, offering syntax and functionalities similar to JASON in a Python environment.Key FeaturesJason-style AgentSpeak interpretationEasy integration with existing Python codeSupport for complex agent constructionsSetuppip install agentspeakRequirementsPython 3.6 or higherAdditional dependencies are automatically installedUsage example!hello_world.

+!hello_world <-
  .print("Hello world!").UsageRun a standalone agent program:$ python -m agentspeak examples/hello_world.aslRun an interactive console:$ python -m agentspeakSeeexamples/embeddedfor an example that interfaces with custom
Python code.Jason compabilitypython-agentspeak should be mostly equivalent toJason.Plan annotations are ignored as of yet.Standard library does not yet contain syntactic transformations with{begin ...}and{end}.Standard library does not yet contain introspective and plan-manipulation
actions.Jason 2.0 fork join operators not yet supported.Literals are only comparable if they have the same signature.
Package: agent-summarizer
Agent SummarizerIntelligent summarizer for various kinds of media sources: web pages, Twitter threads, etc.Early alpha version. Please don't use it for anything serious.Supported media sourcesWeb pagesGitHub projectsArxiv papers annotationsOpen Access (CVPR)Twitter threadsReddit threadsYouTube videos (aspirational; it's beyond text summarization)Installationpipinstallsummarizer
Package: agenttobenamed
A minimalistic LLM agent for Exploratory Data Analysis (EDA) using pandas libraryTask: given a CSV or a XLSX file, respond to user's query about this table by generating a python code and executing it.Using LangChain routers/tagging, a prompt type will be established: to produce a plot or to compute the numerical values.The GPT model breaks down the user's request into several subtasks.The LLM generates code based on these subtasks.The code is executed using the python REPL.If the REPL throws an error, GPT will begin debugging until resolved.The result is the string output of the code 'print(result)' + optionally, saved image with a plot.Query example:'Find correlation between GDP and happiness index, subtract 0.4 and multiply by 1e6.'