Saravanan666/pypi-org huggingface dataset:
Package: pokesim
This package contains a playable pokemon battle simulation game.
Currently supports only a small part of one Pokemon’s moveset. Aims for
Gen VII compatibility; future generations are not guaranteed to be
playable. Also will not feature Mega Evolutions or Z-Moves for the
forseeable future. Double, Triple, Rotation and other misc. battle types
are a huge stretch goal, behind supporting multi-Pokemon teams.InstallationThe easiest way to install is withpip. If your pip installs for
python 3.6+, simply enterpip install pokesimat the command line. To install manually, download this repo and runpython setup.py installUsageOnce installed, you can just runpokesim. The features currently
supported are below:Supported PokemonBulbasaurSupported MovesAmnesiaDouble TeamGrowlRazor LeafSeed BombSweet ScentTackleVine WhipWork UpMissing MechanicsThe following mechanics have yet to be added.WeatherStatus-Effect moves (e.g. Confuse Ray, Fire Fang)Priority moves (e.g. Quick Attack, Extremespeed)Most other things tbhAbilitiesHyper/Reverse Mode(s) (idk which I’ll pick)
Package: pokesummary
PokésummaryIn the heat of a Pokémon battle,
Pokésummary lets you quickly get the information you need!Pokésummary is an easy-to-use, informative command line interface (CLI)
for displaying Pokémon height, weight, types, base stats, and type defenses.
It works completely offline, opting to use local datasets instead of APIs.
It requires no third-party libraries.UsageCommand-line usageThe simplest example is passing a Pokémon name as an argument.
Here, we want to display Bulbasaur's summary,
so we passbulbasauras an argument.pokesummary bulbasaurMultiple Pokémon names can be chained.
Now, we pass the names of Bulbasaur's whole evolution line.
Note that Pokémon names consisting of multiple words
(e.g. Mega Venusaur) must be surrounded by quotation marks.pokesummary bulbasaur ivysaur venusaur "mega venusaur"If you would like to run pokesummary interactively,
use the-iflag.
Now we can type several Pokémon names,
hitting Enter after each one.
Use Ctrl-D (EOF) to exit.pokesummary -iSince the-iflag reads from standard input,
we can pipe Pokémon names to it.
If we have a filepokemon_names.txtfilled with Pokémon names (each separated by newline),
we can use the following to display each of their summaries.cat pokemon_names.txt | pokesummary -iPython library usageStarting from version 2.0.0, you can use Pokésummary as a library.>>>frompokesummary.modelimportPokemonDict>>>pokemon_dict=PokemonDict()>>>my_pokemon=pokemon_dict["Lanturn"]>>>my_pokemonPokemon(name='Lanturn', classification='Light Pokémon', height=1.2, weight=22.5, primary_type=<PokemonType.WATER: 'Water'>, secondary_type=<PokemonType.ELECTRIC: 'Electric'>, base_stats=PokemonBaseStats(hp=125, attack=58, defense=58, special_attack=76, special_defense=76, speed=67))InstallationRequirementsPython 3.7+A terminal supporting ANSI escape codes
(most Linux and macOS terminals,
seeherefor Windows)Install from PyPIInstall using pippip3 install pokesummaryInstall from Source CodeClone or download the repositoryInstall using pippip3 install .UninstallUninstall using pippip3 uninstall pokesummaryContributingPlease seeCONTRIBUTING.md.AcknowledgementsType chart fromPokémon DatabasePokémon data fromYu-Chi Chiang's fixed database
Package: poketypes
poketypesAutomated classes with full typehinting support for pokemon, abilities, items, and so much moreI'm currently migrating code from a mess of a folder on my local machine to this properly formatted repo.
Once everything is moved over, packaged, and properly tested, an official release will be made.Version DetailsWhile the version is below 1.0.0, please note that breaking changes to message/pokedex classes may be made at any time. Additionally, changes may be made without bumping version number, especially while classes/features are being built out.Once the version is 1.0.0, we will follow semantic versioning to the letter, though we will additionally make the following
design guarantees where possible:Full compatibility with pokemon showdown data (This is our ground-truth)Future updated label classes (e.g. DexPokemon) will onlyaddlabels, and will not change any pre-existing onesThis means that the key DexPokemon.POKEMON_MAGIKARP will always have the value 129000, for exampleOutside game knowledge will only be used where absolutely needed, everything else is auto-built from showdown dataWe will also follow the following main guidelines for versioning (based on semantic versioning):MAJOR.MINOR.PATCHWe consider the following to be MAJOR changes:New Generation releasesBreaking changesWe consider the following to be MINOR changes:New fields to messagesExtra functions to add capabilityNew classesMajor bug fixes (e.g. fixing battle message accuracy)We consider the following to be PATCH changes:Rephrasing field descriptionsAdding extra type hintingDocumentation improvementsNiche bug fixes (e.g. animation detail accuracy)Thus, we recommend if you are building on top of poketypes to fix to a given MAJOR version, and verify that nothing breaks for your project before upgrading from one MAJOR version to the next. Our top priority is label-consistancy between versions, so that models expecting the same labels will work on all MAJOR versions. If this priority clashes in some way with any other feature, preserving label integrity will come first.
Package: pokewrap
Pokewrap v1.0.8A wrapper library for the PokeAPI making it easier to build into other python scripts through a quick import. This library is a personal project to done to learn more about package creation and publishing.Pokewrap is not regularly updated, and works with current versions of Python.Please feel free to use it in any of your projects, deconstruct it, and learn from it. If you find any bugs, you cansubmit an issueand I'll work on resolving it ASAP.How it worksPokewrap relies on objects to handle communicating with the API and parse data into meaningful chunks. This ensures a smooth experience working with the returned json, since the objects that wrap it help provide more meaningful access to the data.You can use Pokewrap to connect with the API endpoint and request specific pokemon, or use the generic controller to request berries and other resources. The goal of Pokewrap is to abstract away formatting the API call and parse the returned json for you so you don't have to sweat the details.You can also use it Pokewrap to see which endpoints are available if you're unsure where to start or need to generate a way to pull from several endpoints.Getting StartedYou can either import the library using pip, pulling from the PyPI database, or by downloading this repository. You can also clone/fork this repository to edit it in your own workspace.To use Pokewrap, first import it into your script or service:importpokewrapThen you can start making requests using the ApiController class or choose a resource-specific wrapper (currently only available for Pokemon).Set up the class by specifying as str the type of resource and the specific resource, or as int the Pokemon ID number.For example, to see the Pokemon "Gengar" and its information, set:ApiController("pokemon","gengar")Or, using the ID:ApiController("pokemon",94)If you'd prefer to use the wrapper class, Pokemon, you can simply request information for a Pokemon in the following way:Pokemon("gengar")# Using the namePokemon(94)# Using the IDYou can also use ApiResourceList to get a dictionary response of all viable resources within a supertype (or access the global variable RESOURCE_ENDPOINTS).For example, to see every Pokemon available through the endpoint:ApiResourceList("pokemon")Or use limit/offset values to improve the specificity of your query, overriding the default limits set by PokeAPI:ApiResourceList("pokemon",limit=100,offset=2)Note that the default limit is 20 for resource requests. For larger sets of data, please specify the limit in the function call.For a conprehensive list of all available resource types, check the static RESOURCE_TYPE variable or the dynamically-generated RESOURCE_ENDPOINTS variable.Requesting changesIf you run into an issue or find a bug, pleasesubmit an issueand I'll get the fix rolled out as soon as I can.Since this is intended as a learning project, I don't have immediate plans to continue updating Pokewrap. That said, anyone is more than welcome to submit pull requests and I will approve/add code as applicable. I'm also constantly keeping an eye on the library to at least ensure it continues working.
Package: pokie-container
pokie-containerpokie-container is a Pokie module to manage multiple tree data structures, using the database. It features a multi-tenant,
multi-tree, multi-type node closure table implementation.Adding to a Pokie projectJust add the module name to the module list in yourmain.py:(...)defbuild_pokie():# load configuration from ENVcfg=Config().build()# modules to load & initializemodules=['pokie_container',]# factories to runfactories=[PgSqlFactory]# build apppokie_app=FlaskApplication(cfg)flask_app=pokie_app.build(modules,factories)returnpokie_app,flask_appmain,app=build_pokie()(...)Usage: basic conceptsTree TypeA tree type works as a distinct tree identifier. A given application may have e.g. a user group tree, and an unrelated attribute
tree - these would be distinct tree types within the same application. Each tree has its own node types and its own nodes; there
is no underlying relationship between different tree types, their purpose is to compartmentalize different trees.The best practice to create custom tree types is to add them to the sql migrations of a given project module, and define
the appropriate constants for ID, as their numeric identifier is assigned manually by the programmer. Regardless,
the pokie-container service also provides some methods to add tree types in runtime. The module also provides a default
tree, conveniently using the numeric id 1.Node TypeA node type is a node identifier that can be used for specific application logic. As an example, a LMS application may
use a tree to map a virtual campus, with classrooms with different subjects. These different types of objects could be
mapped as node types.
The module provides a base node type, using the numeric id 1.NodeA node is a container object that is inserted somewhere in the tree. This container object has a specific position in the
tree, a node type, and an underlying tree type. It can also have a custom attribute dictionary, and external numeric reference
for applicational purpose, and a string label.Usage: populating a treefrompokie_container.serviceimportContainerServicefromrick.mixinimportInjectablefrompokie.constantsimportDI_SERVICESfrompokie_container.constantsimportSVC_CONTAINER,NODE_DEFAULT,TREE_DEFAULTclassSampleService(Injectable):defsvc_container(self)->ContainerService:returnself.get_di().get(DI_SERVICES).get(SVC_CONTAINER)defcreate_tree_dump(self,id_tenant:int=0):# create a tree with the following structure#       A#      / \#     B   C#    / \#   D   Esvc_container=self.svc_container()# create nodes with type NODE_DEFAULT# the node type is internally associated with a tree type - in this case, TREE_DEFAULTnode_a=svc_container.add_node(id_tenant,NODE_DEFAULT,"node A")node_b=svc_container.add_node(id_tenant,NODE_DEFAULT,"node B",id_parents=node_a.id)node_c=svc_container.add_node(id_tenant,NODE_DEFAULT,"node C",id_parents=node_a.id)node_d=svc_container.add_node(id_tenant,NODE_DEFAULT,"node D",id_parents=node_b.id)node_e=svc_container.add_node(id_tenant,NODE_DEFAULT,"node E",id_parents=node_b.id)tree=svc_container.get_node_tree(id_tenant,TREE_DEFAULT)# dump treeprint(tree)
Package: pokie-mullet
pokie-mulletBarebones HTTP proxy for Python-powered SPA applications - Mounts a Flask or Pokie application on a slug (/api by default)
and proxies all other requests to a running HTTP server (such as a NodeJS dev server), or to a static SPA on a folder.Basic UsageShow usage parameters:$mullet--helpProxy a local Flask or Pokie API application frommain.pyand a development SPA application running onhttp://localhost:3000:$mulletProxy a local Flask or Pokie API application and a development SPA application locally installed on../dist:$mullet-fe../dist/Proxy a local Flask or Pokie API application on "/slug"  and a development SPA application running onhttp://localhost:3000:$mullet--slug"/slug"
Package: poktbot
PoktBot is a Telegram bot that was born with the mission of helping with the daily tracking of PocketNetwork nodes and their staking rewards.The bot is highly configurable, allowing to track many nodes at once, to generate graph/reports of rewards and to retrieve notifications based on detected errors and status, among other functionalities.DocsGetting started.Installation guide.Configuration guide.FeaturesProvides an easy way to monitoring Pocket Network validator nodes status.Errors monitoring and notification.Staking monitoring and notification.Provides useful stats about node rewards and performance.Daily rewards.Monthly rewards.Graph of rewards evolution.Multi-node and multi-user approach.Average of stats with all configured nodes.Robust RBAC system with two user levels:Investor, only allowed viewing statistics of validators.Admin, same than Investor but also able to add/remove admins, investors and nodes.Creation of economic reports to follow node economics or tax filing.Fully configurable behaviour. Every aspect of the bot is configurable with a configuration file,
and some options through the bot interface itself.Current Status: ExperimentalCode is new and may change or be removed in future versions. Please try it out and provide feedback.
If it addresses a use-case that is important to you please open an issue to discuss it further.Any opinion, bug found, improve request... will be welcome.AuthorsIván de Paz (https://github.com/ipazc)Luis F monge (https://github.com/lucky-luk3)
Package: poku
pokuSymmetrical sync between pocket and buku[-h][-cCONFIG]--consumerCONSUMER[--accessACCESS]-cCONFIG,--configCONFIGconfigfilepath--consumerCONSUMERpocketconsumerkey--accessACCESSpocketaccesskeyFree software: GNU General Public License v3Documentation:https://poku.readthedocs.io.InstallationpipinstallpokuHint:Usepipsito install in a self contained virtualenv.FeaturesSync pocket to bukuSymmetrical sync coming soon!CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-03-27)First release on PyPI.
Package: pokyr
pokyrThis is a python library that provides routines for very fast poker hand
comparisons to power hand match ups.Pure python and c-extention modules are included.  Using the cpoker
module it should be easy to write python code that will, for example,
quickly caluculate expected hand strength squared and opponent cluster
hand strength(EHS2/OCHS).The rank lookup sceme uses 13 magic numbers attributed to thespecialK blog,
which I used to supplement my own algorithm.  A pure python lite version is
also included that leaves a small memory footprint and is still fast.SampleCards are represented by intergers 0-51 and groups of cards are contained
in lists.  The pretty_args wrapper allows you to use standard card strings rather than integers.  You can also convert from integers to pretty cards and back with
utils.make_pretty and utils.to_cards.>>>frompokerimportcpoker>>>frompokerimportutils>>>#return the evs of a match between any number of hands>>>enum=utils.pretty_args(cpoker.full_enumeration)>>>enum(["AsKd","8c2s"])[0.6753362720638392,0.32466372793616083]>>>enum(["AsKd","7h 8h","6c 6d"],"Kc 6h 9h")[0.021040974529346623,0.44518272425249167,0.5337763012181617]>>># percentile on river vs all 990 hand combos>>>utils.pretty_args(cpoker.rivervalue)("As Kd","Ks Qh Jc 8s 8d")0.8585858585858586>>>utils.make_pretty([7,8,9])'Ks Qc Qd'>>>utils.to_cards('Ks Qc Qd')[7,8,9]Compile and InstallIf you have a c compiler the python dev tools for your system then hopefully this does it.  All you need is python 2 or 3 to run the pure python modules.$ python setup.py install
Package: polang
PolangDo not use this with untrusted input!Polangis a simple arithmetic parser that compiles toPolars Expressions.But Why?My usecase is tabular data with a lot of columns that need transformation.Usagedf=DataFrame({"a":np.linspace(0,1),"b":np.sin(np.linspace(0,1))})df.select(polang("(sin(a) + b) * 3.2"))Currently Supported Features+ - * /Braces( )Any method of polars expressions.RoadmapMacros
Package: po-language-server
po-language-serverThis is a Markov-chain based completionlanguage
serverfor
gettextpofiles.Installationpython3 -m pip install po-language-serverIt should be compatible with vim, emacs, vscode, and other text
editors acting as language server clients. I only tried it using emacs
though.Emacs configurationI did not packaged it yet (feel free to help), but it's not that hard
to configure:(require 'lsp-mode)

(add-to-list 'lsp-language-id-configuration '(po-mode . "gettext"))

(lsp-register-client
 (make-lsp-client
  :new-connection (lsp-stdio-connection "po-language-server")
  :activation-fn (lsp-activate-on "gettext" "plaintext")
  :priority -1
  :server-id 'po
))
(add-hook 'po-mode-hook #'lsp)

;; lsp-mode can only work on named buffers
(defun po-mode-name-buffer ()
  (setq-local buffer-file-name "msgstr.po")
  (lsp))

(defun po-mode-unname-buffer ()
  (setq-local buffer-file-name nil))

(add-hook 'po-mode-hook
 (lambda ()
   (advice-add 'po-edit-msgstr :after 'po-mode-name-buffer)
   (advice-add 'po-subedit-exit :before 'po-mode-unname-buffer)))

(add-to-list 'lsp-enabled-clients 'po)
Package: polapy
PolaPyPolaPy (Polarization for Python) is a collection of algorithmic implementations of polarization metrics in Python.It provides:algorithmic implementations for measurements of polarizations introduced in the literature of economics and political scienceuseful tools to manage data for researchfull integration with Pandas DataFramesInstallationThe simplest way to install PolaPy in your laptop is via PyPI:pip install polapyAs this project is in its early stages, please let us know if you have issues installing or running it.About PolaPyThe PolaPy project is developed and maintained by researchers at the University of ConcepciÃ³n. Currently, both the library and the documentation are constantly under update, please let us know if you have any questions or special inquiries.
Package: polar
polarpolar is a Python module that contains simple to use data science functions.
It is built on top of SciPy, scikit-learn, seaborn and pandas.polar buildpython setup.py sdisttwine upload dist/*InstallationIf you already have a working installation of numpy and scipy,
the easiest way to install parkitny is usingpip:pip install polar seaborn pandas scikit-learn scipy matplotlib numpy nltk -UDependenciespolar requires:Python (>= 3.5)NumPy (>= 1.11.0)SciPy (>= 0.17.0)Seaborn (>= 0.9.0)scikit-learn (>= 0.21.3)nltk (>= 3.4.5)python-pptx (>= 0.6.18)cryptography (> 2.8)imblearnJupyter Notebook ExamplesHere is the link to the jupyter notebook with all the exmples that are described belowPolar-ExamplesACA (Automated Cohort Analysis) ExampleThe ACA creates three heatmaps for each feature in the data set.Conversion heatmap - conversion per feature valueDistribution heatmap - distribution per feature valueSize heatmap - total samples per feature valueimportpandasaspdimportpolarasplfrompptximportPresentation%matplotlibinlineurl="https://raw.githubusercontent.com/pparkitn/imagehost/master/ACA_date.csv"data_df=pd.read_csv(url)prs=Presentation()pl.create_title(prs,'ACA')forchartinpl.ACA_create_graphs(data_df,'date','label'):pl.add_chart_slide(prs,chart[0],chart[1])pl.save_presentation(prs,filename='ACA')Conversion:Distribution:Samples:EDA Exampleimportpandasaspdimportopenmlimportpolaraspldataset=openml.datasets.get_dataset(31)X,y,categorical_indicator,attribute_names=\dataset.get_data(target=dataset.default_target_attribute,dataset_format='dataframe')openml_df=pd.DataFrame(X)openml_df['target']=ydata_df=pl.analyze_correlation(openml_df,'target')pl.get_heatmap(data_df,'correlation_heat_map.png',1.1,14,'0.1f',0,100,5,5)data_df=pl.analyze_association(openml_df,'target',verbose=0)pl.get_heatmap(data_df,'association_heat_map.png',1.1,12,'0.1f',0,100,10,10)print(pl.analyze_df(openml_df,'target',10))data_df=pl.get_important_features(openml_df,'target')pl.get_bar(data_df,'bar.png','Importance','Feature_Name')NLP Exampleimportnltknltk.download('wordnet')importpandasaspdimportpolarasplfromcryptography.fernetimportFerneturl="https://raw.githubusercontent.com/pparkitn/imagehost/master/test_real_or_not_from_kaggle.csv"data_df=pd.read_csv(url)data_df.drop(columns=['id','keyword','location'],inplace=True)data_df.head(3)key=Fernet.generate_key()data_df['text_encrypted']=data_df['text'].apply(pl.encrypt_df,args=(key,))data_df['text_decrypted']=data_df['text_encrypted'].apply(pl.decrypt_df,args=(key,))data_df['text_stem']=data_df['text_decrypted'].apply(pl.nlp_text_process,args=('stem',))data_df['text_stem_lem']=data_df['text_stem'].apply(pl.nlp_text_process,args=('lem',))data_df.head(3)cluster_df=pl.nlp_cluster(data_df,'text_stem_lem',10,'text_cluster',1.0,1,100,1,'KMeans',(1,2))[0]cluster_df.groupby(['text_cluster']).count()cluster_df[cluster_df['text_cluster']==9]['text_stem_lem']
Package: polar-accesslink
Polar AccessLink API ClientLibrary to enable access to Polar training data through thePolar Open AccessLinkAPI. This library is a forked and packaged version of the officalPolar AccessLink example client.Free software: MIT licensePrerequisitesPolar FlowaccountGetting Started1. Create new API clientNavigate tohttps://admin.polaraccesslink.com. Log in with your Polar Flow account and create a new client using an appropriate OAuth2 callback URL for your application. Note the client ID and client secret -- you will need these later.2. Authorize accessUser account needs to be linked to client application before client can get any user data. User is asked for authorization in Polar Flow, and user is redirected back to application callback url with authorization code once user has accepted the request. Navigate to the URL given byget_authorization_url()to authorize the account access.Sample code:from accesslink import AccessLink

accesslink = AccessLink(client_id=CLIENT_ID,
                        client_secret=CLIENT_SECRET,
                        redirect_url=REDIRECT_URL)

# Navigate the user to the following URL so they can complete the authorization form.
# Code for this will vary by application.
auth_url = accesslink.get_authorization_url()3. Link userYour application should handle the callback request appropriately, storing the user ID and access token which will be necessary for later API calls. The user must first be registered with the given access token before additional API calls can be made.Sample code:from accesslink import AccessLink

accesslink = AccessLink(client_id=CLIENT_ID,
                        client_secret=CLIENT_SECRET,
                        redirect_url=REDIRECT_URL)

authorization_code = request.args.get("code")
token_response = accesslink.get_access_token(authorization_code)

USER_ID = token_response["x_user_id"]
ACCESS_TOKEN = token_response["access_token"]

try:
    accesslink.users.register(access_token=ACCESS_TOKEN)
except requests.exceptions.HTTPError as err:
    # Error 409 Conflict means that the user has already been registered for this client.
    # For most applications, that error can be ignored.
    if err.response.status_code != 409:
        raise err4. Access API dataOnce user has linked their user account to client application and synchronizes data from Polar device to Polar Flow, application is able to load data.Sample code:from accesslink import AccessLink

accesslink = AccessLink(client_id=CLIENT_ID,
                        client_secret=CLIENT_SECRET)

user_info = accesslink.users.get_information(user_id=USER_ID,
                                             access_token=ACCESS_TOKEN)