Saravanan666/pypi-org huggingface dataset:
Package: py-ai-cli
AI Tools for chatGPTThis CLI tool allows you to conveniently use chatGPT or new bing in the command line interface. You can chat with it or ask it questions. It can also help you translate text and supports rendering
markdown in the terminal.English|中文|日本語DependenciesOPENAI_API_BASE (optional)If you are unable to accesshttps://api.openai.comdue to GFW, you can specify another API address using theOPENAI_API_BASEenvironment variable. It is recommended to use this method as it is
more stable than using a proxy. For information on how to use Cloudflare Workers to set up a proxy, seeSetting up an OpenAI API Proxy with Cloudflare
Workers.OPENAI_API_KEYYou can set theOPENAI_API_KEYenvironment variable or specify it using the--api-keyparameter. You can also set it using theai settingcommand.If you use Azure OpenAI, you can set theAZURE_OPENAI_API_KEYorAZURE_OPENAI_AD_TOKENenvironment variable. andAZURE_OPENAI_ENDPOINTfor Azure OpenAI endpoint.Gemini ProIf you use the Gemini, you can set theGOOGLE_API_KEYor--google-api-keyparameter. You can also set it using theai settingcommand. Need to set bot toGeminiBotbyai setting --edit bot=GeminiBot.
Now, supportgemini-promode only. You can set byai setting --edit mode=gemini-pro, orai --mode gemini-pro.Bard Support [Deprecated]If you use the Bard Bot, you must be logged into Google Bard on at least one browser, which will automatically be detected.Bing CookieIf you use the Bing Bot, you need to set the Bing Cookie. You can set it using theai settingcommand.aisetting--editbing_cookie="BING_COOKIE.JSON"For information on how to get the cookie, seeChecking Access Required for Bing Bot.Installationpipinstallpy-ai-cliAlternatively, install the latest version:pipinstallgit+https://github.com/yufeikang/ai-cli.gitConfigurationYou can now set the API key and API base using theai settingcommand. Environmental variables and CLI parameters are still valid.# View settingsaisetting# Set settingsaisetting-eUsageUseai -hto view all supported commands.Automatic Commit MessagesaicommitAsk a Questionaiask"Hello"# no stream modeai--no-streamask"Hello"# helpaiask--help# use pre promptcurl-shttps://raw.githubusercontent.com/yufeikang/ai-cli/main/README.md|aiask--prompt"summary this, how to install"Translationaitranslate"Hello"aitranslate"Hello"-tjapanese
aitranslate-tenglish-f"file.txt"echo"Hello"|aitranslate-tenglish
cat"file.txt"|aitranslate-tenglishChattingaichatCode Reviewaireview
aireview-tdevelop
aireview-tHEAD~1Proxy SupportOPENAI_API_BASE is more stable with a forward proxy. It is recommended.Support environment variablesHTTP_PROXYandHTTPS_PROXY, orALL_PROXY. You can also specify a proxy using the--proxyparameter.For example:exportHTTP_PROXY=http://x.x.x.x:xxxx# orexportHTTPS_PROXY=https://x.x.x.x:xxxxSOCKS5 proxy is also supported, for example:exportALL_PROXY=socks5://x.x.x.x:xxxxSOCKS5 proxy requirespip install pysocks.Additional InformationPlease useai --helpto view more commands.ThanksThis project is developed usingJetBrainsproducts.
Package: pyaid
# pyaidA supporting library of utility code for Python.MIT LicenseCopyright (c) 2020 Jonathan DeCarloPermission 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: pyaig
PyAIG: A simpe Python AIG and Truth Table packageAIGAnd-Inverter Graph (AIG) is a data structure for logic synthesis and verification. The code follows theAIGERconventions.InstallationInstall usingpip:pipinstall.Truth Tables exampleImport the packagefrompyaigimport*Create the truth table manger - the max number of variables is requiredm = truth_tables(6, "ABCDEF")If the second parameter totruth_tablesis provided, it automatically inserts the sequence of names into the global namespaceBuild truth tables with operator overloadingf=A.ite(B,C^D)&E|FThe truth table support|,&,^, and~for OR, AND, XOR, INVERT, respectively. It also supportsite(if-then-else),iff(if-and-only-if, or EXOR) andimplies(logical implication).Output the truth tableprint(f)Will print the truth as a prime-irredudant cover, in this case:A&B&E+~A&C&~D&E+~A&~C&D&E+FOr,print(f.SOP())Resulting in-----1 1
0-011- 1
0-101- 1
11--1- 1Orprint(f.isop())Resulting in[{1, 2, 5}, {3, -4, 5, -1}, {-3, 4, 5, -1}, {6}]All three are the same cover. The first is a human-readable expression. The second is similar to Espresso and BLIF formats, and the third is the list of cubes where negative means negation and the nubmer is the variable number starting from 0.Manipulate truth tablesIn addition to the above, it supports permuting and negating inputs and the output, generating the list of all NPN-equivalent functions and a few other operations.
Package: py-aiger-abc
py-aiger-abcAiger <-> ABC bridgeInstallationNon-Python DependenciesThis package currently assumes that theABCandaigtoaigcommands are installed and in the
PATH. In the future, we hope to automatically include these
dependencies, but currently one needs to install them on their own.Python PackageIf you just need to useaiger_abc, you can just run:$ pip install py-aiger-abcFor developers, note that this project uses thepoetrypython package/dependency
management tool. Please familarize yourself with it and then run:$ poetry installUsageThe primary entry point for usingaiger_abcis thesimplifyfunction which usesabcto simplify an AIG. For example, below we
show howaiger_abccan be used to simplify the following inefficient
encoding of const false.importaigerx=aiger.atom('x')f=x^xprint(f.aig)aag 4 1 0 1 3
2
8
4 2 2
6 3 3
8 5 7importaiger_abcf2=aiger_abc.simplify(f)print(f2.aig)aag 1 1 0 1 0
2
0Explicitly Specifying forabcandaigtoaigcommandssimplifysupports explicitly specifying theabcandaigtoaigcommands. This is useful
if you have installed them in non-standard paths
or names. E.g.,f2=aiger_abc.simplify(f,abc_cmd='abc',aigtoaig_cmf='aigtoaig')
Package: py-aiger-bdd
py-aiger-bddInstallation$ pip install py-aiger-bddFor developers, note that this project uses thepoetrypython package/dependency
management tool. Please familarize yourself with it and then
run:$ poetry installUsageThis tutorial assumes familiarity withpy-aigerandpy-aiger-bv.importaiger_bvasBVfromaiger_bddimportto_bdd,from_bdd,countx=BV.atom(3,'x',signed=False)expr=x<5# Could be an AIG or AIGBV or BoolExpr.bdd,manager,input2var=to_bdd(expr)# Convert circuit encoded by expr into a BDD.expr2=from_bdd(bdd)# Creates an Aiger Expression from a BDD.assertcount(expr,fraction=True)==5/8assertcount(expr,fraction=False)==5
Package: py-aiger-cnf
py-aiger-cnfPython library to convert between AIGER and CNFTable of ContentsInstallationUsageInstallationIf you just need to useaiger_cnf, you can just run:$ pip install py-aiger-cnfFor developers, note that this project uses thepoetrypython package/dependency
management tool. Please familarize yourself with it and then
run:$ poetry installUsageThe primary entry point for usingaiger_cnfis theaig2cnffunction which, unsurprisingly, mapsAIGobjects toCNFobjects.importaigerfromaiger_cnfimportaig2cnfx,y,z=map(aiger.atom,('x','y','z'))expr=(x&y)|~zcnf=aig2cnf(expr.aig)Note that this library also supportsaigerwrapper libraries so long
as they export a.aigattribute. Thus, could also
write:cnf=aig2cnf(expr)TheCNFobject is aNamedTuplewith the following three fields:clauses: A list of tuples of ints, e.g.,[(1,2,3), (-1, 2)]. Each integer represents a variable's id, with the sign
indicating the polarity of the variable.input2lit: Abidictfrom input names to variable ids.output2lit: Abidictfrom output names to variable ids.
Package: py-aiger-coins
py-aiger-coinswarning3.0.0 and greater are amajorrewrite of this code
base. I am trying to port most of the useful features.Library for creating circuits that encode discrete distributions and
Markov Decision Processes. The name comes from the random bit model of
drawing from discrete distributions using coin flips.Table of Contentspy-aiger-coinsInstallUsageInstallTo install this library run:$ pip install py-aiger-coinsNote that to actually compute probabilities, one needs to install with the bdd option.$ pip install py-aiger-coins[bdd]For developers, note that this project uses thepoetrypython package/dependency
management tool. Please familarize yourself with it and then run:$ poetry installUsagepy-aiger-coinsextends the standardpy-aiger-bvandpy-aiger-discreteabstractions to allow for certain bits to be set
viabiasedcoins.The library centers around thePCircobject. The easiest way to usepy-aiger-coinsis to throught thepcircfunction.importaiger_bvasBVimportaiger_coinsasCexpr1=BV.uatom(2,'x')+BV.uatom(2,'y')# Create distribution over bits.my_pcirc=C.pcirc(expr1)\.randomize({'x':{0:1/6,1:2/6,2:3/6}})assertmy_pcirc.outputs=={expr1.output}# This probablistic circuit uses 2 biased coins to represent this input.assertmy_pcirc.num_coins==2assertmy_pcirc.coin_biases==(1/3,1/2)# 'x' input is replaced with coinflips.assertmy_pcirc.inputs=={'y'}# Underlying circuit now has a single input representing coin inputs.underlying_circ=my_pcirc.circassertunderlying_circ.inputs=={'y',my_pcirc.coins_id}Note thataiger_coins.PCircimplements the same API asaiger_bvandaiger_coins.Sequential Circuit APIFor example, sequential and parallel composition allow combining
probablistic circuits.incr=(BV.uatom(2,'z')+1)adder=(BV.uatom(2,'x')+BV.uatom(2,'y')).with_output('z')# Create distribution over bits.pcirc=C.pcirc(adder)\.randomize({'x':{0:1/6,1:2/6,2:3/6}})pcirc>>=incrorinc_x=C.pcirc(BV.uatom(2,'x')+1)\.randomize({'x':{0:1/3,2:2/3}})# Pr(x=2) = 2/3inc_y=C.pcirc(BV.uatom(3,'y')+1)\.randomize({'y':{0:1/3,5:1/3,3:1/3}})inc_xy=inc_x|inc_y#Similarly,unroll,loopbackare also implemented.noteunrollcombines all coin flips into asingleinput in
temporal order.Finite Functionspy-aiger-coinsalso works well with thepy-aiger-discreteAPI for
working with arbitrary functions over finite sets. For example:frombidictimportbidict# `pip install bidict`# Create encoder/decoder for dice.lookup=bidict({0:'⚀',1:'⚁',2:'⚂',3:'⚃'})# invertable dictionary.encoder=aiger_discrete.Encoding(decode=lookup.get,encode=lookup.inv.get)# Represent dice with a 2 bit vector.expr1=BV.uatom(2,'🎲')# Add encoded dice to x. Because why not.expr2=BV.uatom(2,'x')+expr1func=aiger_discrete.from_aigbv(expr2.aigbv,input_encodings={'🎲':encoder})# Create distribution over bits.circ=C.pcirc(func)\.randomize({'🎲':{'⚀':1/6,'⚁':2/6,'⚂':3/6}})assertcirc.inputs=={'x'}assertcirc.outputs=={expr2.output}assertcirc.coin_biases==(Fraction(1,3),Fraction(1,2))
Package: py-aiger-dfa
py-aiger-dfaPython library for converting between AIG circuits and DFAs.Table of ContentsInstallationUsageDFA to AIGAIG to DFAInstallationIf you just need to useaiger_dfa, you can just run:$ pip install py-aiger-dfaFor developers, note that this project uses thepoetrypython package/dependency
management tool. Please familarize yourself with it and then
run:$ poetry installUsageThe main entry points for using this library are thedfa2aigandaig2dfafunctions. DFAs are represented using thedfapackage. Familiarity with thedfa,py-aiger, andpy-aiger-bvpackages is assumed.DFA to AIGAn example of going from aDFAto anAIGobject
is shown below.fromdfaimportDFAfromaiger_dfaimportdfa2aigmy_dfa=DFA(start=0,inputs={0,1},label=lambdas:(s%4)==3,transition=lambdas,c:(s+c)%4,)my_aig,relabels,valid=dfa2aig(my_dfa)Nowcircis anAIGandrelabelsis a mapping from the inputs,
states, and outputs ofmy_dfato their1-hotencoded
counterparts inmy_aig.relabelshas the following schema:relabels={'inputs':..,#  Mapping from input alphabet -> py-aiger input.'outputs':..,# Mapping from py-aiger output -> output alphabet.'states':..,# Mapping from state space -> py-aiger latches.}Finally,validis another aiger circuit which tests if all inputs
are 1-hot encoded.AIG to DFAWe also support converting a sequential circuit (AIG) to aMoore
Machine(DFA) usingaig2dfa. Using the same example:fromaiger_dfaimportaig2dfamy_dfa2=aig2dfa(my_aig,relabels=relabels)Note that the output of a sequential circuit (AIG) is dependent on the
stateANDthe action (aMealy
Machine).We use the standard Mealy ↦ Moore reduction where one introduces a
1-step delay on the output. The default initial output isNone, but
can be set using theinitial_labelargument.
Package: py-aiger-discrete
py-aiger-discreteLibrary for modeling functions over discrete sets using aiger circuits.InstallationIf you just need to usepy-aiger-discrete, you can just run:$ pip install py-aiger-discreteFor developers, note that this project uses thepoetrypython package/dependency
management tool. Please familarize yourself with it and then
run:$ poetry installAboutThis library helps with modeling functions over finite sets using circuits.f : A → B₁ × B₂ × … × BₘwhereA ⊆ A₁ × A₂ × … × Aₙ.This is done by providing:A encoder/decoder pair for each set to and from (unsigned)
integers.A circuit that uses the bit-vector representation of these integers
to computef.A circuit that monitors if the input bit-vector sequence isvalid, i.e., a member ofA.Functionally, thepy-aiger-discretelibrary centers around theaiger_discrete.FiniteFuncclass which has 4 attributes anaiger_bv.AIGBVobject.A stringvalid_idindicatingA circuit,circ, over named bit-vectors in the form of anaiger_bv.AIGBVobject. One of the outputs must be namedvalid_id.A mapping frominputstoaiger_discrete.Encodingobjects which
encode/decode objects to integers. The standard bit-encoding of
unsigned integers is feed intocirc.A mapping fromoutputstoaiger_discrete.Encodingobjects which
encode/decode objects to integers. These encodings are used to decode
the resulting bit-vectors ofcirc.UsageBelow we provide a basic usage example. This example assumes basic
knowledge of thepy-aigerecosystem and particularlypy-aiger-bv.importaiger_bvasBVfromaiger_discreteimportEncoding,from_aigbv# Will assume inputs are in 'A', 'B', 'C', 'D', or 'E'.ascii_encoder=Encoding(decode=lambdax:chr(x+ord('A')),# Make 'A' map to 0.encode=lambdax:ord(x)-ord('A'),)# Create function which maps: A -> B, B -> C, C -> D, D -> E.x=BV.uatom(3,'x')# need 3 bits to capture 5 input types.update_expr=(x+1)&0b111circ=update_expr.with_output('y').aigbv# Need to assert that the inputs are less than 4.circ|=(x<=4).with_output('##valid').aigbvfunc=from_aigbv(circ,input_encodings={'x':ascii_encoder},output_encodings={'y':ascii_encoder},valid_id='##valid',)assertfunc('A')=='B'assertfunc('B')=='C'assertfunc('C')=='D'assertfunc('D')=='E'assertfunc('E')=='A'Note thatpy-aiger-discreteimplements most of the circuit API asaiger_bv.AIGBV.For example, sequential composition:func12=func1>>func2or parallel composition:func12=func1|func2or unrolling:func_unrolled=func1.unroll(5)or feedback:func_cycle=func1.loopback({'input':'x','output':'y','keep_output':True,`input_encoder`:True,`init`:'A',})Note that feedback now supports additional flag per wiring description
calledinput_encoderwhich determines if the input or output
encoding is used for initial latch value resp. The default is the
input encoding.or renaming:func_renamed=func1['i',{'x':'z'}]assertfunc1.inputs=={'z'}
Package: py-aiger-ptltl
py-aiger-past-ltlLibrary for generating (p)ast (t)ense (l)inear (t)emporal (l)ogic
monitors as aiger circuits. Builds on thepy-aigerproject.Table of ContentsInstallationUsageInstallationIf you just need to useaiger_ptltl, you can just run:$ pip install py-aiger-ptltlFor developers, note that this project uses thepoetrypython package/dependency
management tool. Please familarize yourself with it and then
run:$ poetry installUsageThe primary entry point for usingaiger_ptltlis thePTLTLExprclass which is a simple extension ofaiger.BoolExprto support the
temporal operators, historically, past (once), (variant) yesterday,
and since.importaiger_ptltlasptltl# Atomic Propositionsx=ptltl.atom('x')y=ptltl.atom('y')z=ptltl.atom('z')# Propositional logicexpr1=~xexpr2=x&(y|z)expr3=(x&y)|~zexpr4=~(x&y&z)# Temporal Logicexpr5=x.historically()#  (H x) ≡ x has held for all previous cycles (inclusive).expr6=x.once()#  (P x) ≡ x once held in a past cycle (inclusive).expr7=x.vyest()#  (Z x) ≡ x held in the previous cycle (true at time = 0).expr8=x.yest()#  (Y x) ≡ x held in the previous cycle (false at time = 0).expr9=x.since(y)#  [x S y] ≡ x has held since the cycle after y last held.# Compositionexpr9=expr7.since(expr9.vyest().vyest())
Package: py-aiger-sat
py-aiger-satPythonic interface between AIGs and SAT solvers.Table of ContentsInstallationUsageInstallationIf you just need to useaiger_sat, you can just run:$ pip install py-aiger-satFor developers, note that this project uses thepoetrypython package/dependency
management tool. Please familarize yourself with it and then
run:$ poetry installUsageaiger_sathas two seperate API's. The first, called the Object API,
centers around theSolverWrapperobject - a thin wrapper around apysatsolver. The second is a Function API which exposes 4 functionssolve,is_sat,is_valid, andare_equiv. The function API is
primarily useful for simple 1-off SAT instances, where as the object
API is more useful when incremental solves are needed, or the
underlyingpysatsolver must be exposed.Object APIfromaiger_satimportSolverWrappersolver=SolverWrapper()# defaults to Glucose4frompysat.solversimportGlucose3solver2=SolverWrapper(solver=Glucose3)solveroperate on boolean expressions in the form ofaigercircuits with a single output. For example,importaigerx,y,z=map(aiger.atom,['x','y','z'])expr=(x&y)|~zsolver.add_expr(expr)assertsolver.is_sat()model=solver.get_model()print(model)# {'x': True, 'y': False, 'z': False}assertexpr(model)Further,aiger_satsupports making assumptions and computing
unsat_cores.# Make invalid assumption.assertnotsolver.is_sat(assumptions={'x':False,'z':True,})assertnotsolver.unsolvedcore=solver.get_unsat_core()assertcore=={'x':False,'z':True}Function APIimportaigerimportaiger_satx,y,z=map(aiger.atom,['x','y','z'])assertaiger_sat.is_sat(x&y&z)model=aiger_sat.solve(x&y&z)assertmodel=={'x':True,'y':True,'z':True}assertaiger_sat.is_valid(aiger.atom(True))expr1=x&yexpr2=x&y&(z|~z)assertaiger_sat.are_equiv(expr1,expr2)BitVector Supportpy-aiger-satalso natively supports thepy-aiger-bvbitvector
library.To enable this support, make sure thatpy-aiger-bvis installed,
either manually:$ pip install py-aiger-bvor by installingpy-aiger-satwith thebitvectoroption:$ pip install py-aiger-sat[bitvector]or$ poetry install --extras=bitvectorUsage is analogous to the non-bitvector usage.fromaiger_bvimportatomfromaiger_satimportsat_bv# Object APIexpr=atom(4,'x')&atom(4,'y')<2f=sat_bv.SolverBVWrapper()f.add_expr(expr)model=f.get_model()# Function API.model=sat_bv.solve(expr)print(model)# {'x': (False, False, True, True), 'y': (False, False, True, True)}
Package: pyaiken
pyaikenThis package supplies python bindings for the packageaiken.
The bindings are added on a per-need basis, currently only serving the development ofopshinInstallationInstall python3. Then run the following command.python3-mpipinstallpyaikenUsagefrompyaikenimportuplc# Tools for handling UPLC### uplc.flat# Print the hex of the CBOR encoded flat-encoding of the program in UPLC textual notationcode=uplc.flat("(program 1.0.0 (con data #01))")print(code)# prints "490100004c0101010001"### uplc.unflat# Print the UPLC in textual notation from the hex of the CBOR encoded flat-encodingcode=uplc.unflat("490100004c0101010001")print(code)# prints "(program 1.0.0 (con data #01))"### uplc.eval# Evaluate a UPLC program with the given arguments (all in textual representation) and cpu and memory budget (optional, in this order)# Returns either computed UPLC value on success or thrown error on failure,# logs generated through trace# and the consumed cpu and memory steps((suc,err),logs,(cpu,mem))=uplc.eval("(program 1.0.0 (lam x x))",["(con data #01)"],1000000,None)print((suc,err),logs,(cpu,mem))# prints "('(con data #01)', None), [], (92100, 500)"BuildingIn case you need to build this package from source, install Python3 and Rust and proceed as follows.gitclonehttps://github.com/OpShin/pyaikencdpyaiken
python3-mvenv.envsource.env/bin/activate# or in whichever environment you want to have it installedpipinstallmaturin
maturinbuildThe package will be installed in the active python environment.
Package: pyail
PyAILPyAIL - Python library using the AIL Rest APIPyAIL is a Python library to accessAILplatforms via their REST API.Install from pipIt is strongly recommended to use a virtual environmentIf you want to know more about virtual environments,python has you coveredInstall pyail:pip3installpyailUsageFeeding items to AILfrompyailimportPyAILail_url='https://localhost:7000'ail_key='<AIL API KEY>'try:pyail=PyAIL(ail_url,ail_key,ssl=False)exceptExceptionase:print(e)sys.exit(0)data='my item content'metadata={}source='<FEEDER NAME>'source_uuid='<feeder UUID v4>'pyail.feed_json_item(data,metadata,source,source_uuid)LicenseThis software is licensed under BSD 3-Clause LicenseCopyright (C) 2020-2023 CIRCL - Computer Incident Response Center LuxembourgCopyright (C) 2020-2023 Aurelien Thirion
Package: pyaiml21
pyaiml21AIML [^AIML] 2.1 Chatbot Design Language Interpreter in Python 3.The AIML language is a (simple) XML-derived language for description of chatbots
and the communication with the user based on the pattern-matching the user's
query and evaluating (human-coded) response.pyaiml21is an AIML interpreter, supporting the latest AIML specification.
It was created as a bachelor thesis and should be fully compatible with
its predecessor,PyAiml[^pyaiml].InstallationInstall the project fromPYPI:$ python -m pip install pyaiml21Quick ExampleThis example demonstrates how to quickly set-up and run a basic chatbot with
publicly available source files from ALICE [^ALICE].Running via console scriptpyaiml21comes with a simple script to run your chatbots, if you unpacked
the contents of your bot intoalice/folder (so that the structure
isalice/aiml/..,alice/aimlif/..,alice/sets/....), then running
the following will start your bot:$ aiml --bot aliceRunning from PythonIt is still possible to start your bot directly from python[^example], e.g.>>> from pyaiml21 import Bot
>>> my_bot = Bot()
>>> my_bot.learn_aiml("path to .aiml file")
>>> # more loading stuff, see `pyaiml21.utils` for helpers
>>> my_bot.respond("Hello", "USER_1")
Hi! How are you doing?For examples of simple bots, checkout/examplesfolder.MotivationThis project was created to support the AIML 2.1 in Python while preserving
the simplicity of user interface frompyaiml. Note that for Python,
there exists an AIML interpreter,program-y[^program-y], but it does
come with the full chatbot platform, the simple interface is missing.DocumentationPlease visit theofficial documentation.LicenseMIT.[^ALICE]:alice source code[^AIML]: Artificial Intelligence Markup Language (Dr. Wallace, 2001); see
the officialspecification of version 2.1[^example]: The actual response depends on your AIML file, to load .aimlif,
substitutions.., see methods ofpyaiml21.Bot[^pyaiml]:original interpreter in python for AIML 1.0[^program-y]:AIML Interpreter in Python3