package
stringlengths 1
122
| pacakge-description
stringlengths 0
1.3M
|
|---|---|
ament-lint-cmake-py
|
The ability to lint CMake code using cmakelint and generate xUnit test
result files.
|
ament-lint-flake8
|
The ability to check code for syntax and style conventions with flake8.
|
ament-lint-pep257
|
The ability to check code against the docstring conventions in PEP 257
and generate xUnit test result files.
|
ament-mypy
|
The ability to check code for user specified static typing with mypy.
|
ament-pycodestyle
|
The ability to check code against the style conventions in PEP 8 and
generate xUnit test result files.
|
ament-style-uncrustify
|
The ability to check code against style conventions using uncrustify
and generate xUnit test result files.
|
ament-xmllint
|
The ability to check XML files like the package manifest using xmllint
and generate xUnit test result files.
|
amenu
|
````pythonamenuThis is a menu plugins for DjangoCMS. It provides 4 different kinds of menu plugins.1. Menu Below Current Page2. Breadcrumb3. Generic Menu4. Selective MenuInstallationDownload the package$ pip install amenuRegister it to the INSTALLED_APPSFor standard DjangoCMS project settingINSTALLED_APPS = ('amenu',)For "Djangocms Foundation"[https://github.com/ludbek/djangocms-foundation]DJANGO_CMS_APPS = ('amenu',)Migrate the plugin$ python manage.py migrate amenu````
|
amenukit
|
This module is in its infancy and as it’s goals are very ambitious there is no
guarantee that it will survive. The following are the goals of the project not
a statement of achievement. At the moment it should be considered ‘vapourware’This module will simplify the specification, creation, and
dynamic manipulation of gui menus. Menus systems written with this module will
work without modification on all supported gui’s.The kit supplies wrappers for four common python gui’s:tkinter [tkmenukit.py]pygtk [gtkmenukit.py]pyqt [qtmenukit.py]wxPython [wxmenukit.py]Menus are represented by python objects linked together in a tree structure. The
python objects can be inactive, or active. Active menus are connected to real
menus in the gui and changes made to the python structure will be reflected in
the gui.Menus (and menu fragments) can be built up using normal python methods for
manipulating data structures or from lists of python strings or from data
formats such as XML, jason, yaml etc. Python menu structures, however
constructed, can be converted easily into any of these formats.Porting a menu system from one gui to another, simply involves importing a
different wrapper module. Everything else will work exactly the same.
|
amepy
|
An API Wrapper that interacts with the Améthyste APIDocumentationhttps://pyame.readthedocs.io/en/latestInstallationRequires python 3.7 or higher# Linux/MacOSpython3-mpipinstallpyame# Windowspy-3-mpipinstallpyameLicenseMIT
|
amer
|
Failed to fetch description. HTTP Status Code: 404
|
amera
|
Failed to fetch description. HTTP Status Code: 404
|
amerdistribution
|
No description available on PyPI.
|
america
|
Jacobbe08#1148
|
americanas-scraper
|
Americanas crawler and scraper using beautifulsoup4.Usage examplePara utilizar em sua aplicação basta instanciar
passando os parâmetros da pesquisa.
# Exemplo: americanas_scraper.search(url=””)Cli usageamericanas –url=URLInstallingpip install pip install americanas_scraper
|
americano
|
No description available on PyPI.
|
american-options
|
American Options LibraryThe Library that is using various methods to price the variety of options of american type.Installationpip install american_optionsGet startedHow to obtain option price with this library:fromamerican_optionsimportOption,Underlying#Set up your parametersn_sims=10000T=1sigma1=0.4sigma2=0.8r=0.06N=255spot1=100spot2=120K1=100K2=110First you need to create assets you want to write options on. You can do this in following way:# Instantiate an Underlying objectasset1=Underlying(spot_price=100,r=0.07)asset2=Underlying(spot_price=120,r=0.07)Next step is to calibrate assets for the use of different models.# Calibrate created assetsasset1.calibrate_GBM(sigma=0.4,values_per_year_GBM=N)asset1.calibrate_JD(sigma=0.4,jump_intensity=1/3)asset2.calibrate_GBM(sigma=0.4,values_per_year_GBM=N)asset2.calibrate_JD(sigma=0.2,jump_intensity=1/2)Now create options, for that we need payoff functions as well. You can import some of them from payoffs module:fromamerican_options.payoffsimport*option1=Option(underlyings=asset1,payoff_func=lambdatrajectory:payoff_creator_1d(trajectory,Call_Payoff,K=100,barrier=True,barrier_level=140),T=1)option2=Option(underlyings=(asset1,asset2),payoff_func=lambdatrajectories:double_max_put(trajectories,100),T=1)And finally obtaining a price!# Pricing with state space partitioning methodoption1.ssp(n_sims=10000,mode='JD')option2.ssp(n_sims=10000,mode='GBM')# pPricing with Longstaff-Schwartz methodoption1.LS(n_sims=10000,mode='JD')option2.ssp(n_sims=10000,mode='GBM')
|
americium
|
Example PackageThis is a simple example package. You can useGitHub-flavored Markdownto write your content.
|
amerikana
|
☕ amerikana:kerasprediction decoder forimagenet-simple-labelsa simpler, more human readable imagenet synset for keras.comparison:IDImageNetKerasSimple (this repo)87African grey, African gray, Psittacus erithacusAfrican_greygrey parrot97drakedrakeduck913wreckwreckshipwreck930French loafFrench_loafbaguettequickstart:should be used as a drop in replacement fortf.keras.applications.imagenet_utils.decode_predictionsinstall with pip:pip install amerikanaimport:from amerikana import decode_predictionsinstead of:from tensorflow.keras.applications.imagenet_utils import decode_predictionsexample use:predictions = model.predict(processed_image)
labels = decode_predictions(predictions)
print(labels)credit:simplified labels list:imagenet-simple-labels. see information and comparison for simplified labels there.the module code used in this project is a derivative of tf.kerasimagenet_utils.enjoy!
|
ameritrade-python
|
ameritrade-pythonThis is a simple and lightweight async api wrapper for Ameritrade's API.The official docs for the Ameritrade API can be foundhere.The first time authentication will require utilizing the callback URL/redirect URI to obtain your tokens.
This package will generate an auth url to enter into a web browser, you can then paste the resulting url from the
redirect url in order to obtain a pair of tokens.fromosimportenvironfromameritradeimportauthtest_redirect_uri=environ.get("callback_url")consumer_key=environ.get("consumer_key")test_auth=auth.Auth(redirect_uri=test_redirect_uri,consumer_key=consumer_key)defmain():"""Sets the access and refresh tokens by following terminal prompts."""awaittest_auth.manual_auth()Simple usage using an existing refresh token:importasynciofromosimportenvironfromameritradeimportauth,stocktest_redirect_uri=environ.get("callback_url")consumer_key=environ.get("consumer_key")refresh_token=environ.get("refresh_token")test_auth=auth.Auth(redirect_uri=test_redirect_uri,consumer_key=consumer_key,refresh_token=refresh_token)asyncdefmain():"""Gets new tokens, then gets a single stock quote for 'KO'/coca-cola."""awaittest_auth.refresh_token_auth()# Gets fresh tokenstest_stock=stock.Stock(auth_class=test_auth,symbol="ko")# creates stock object for KOawaittest_stock.get_quote()# Makes the quote requestprint(test_stock.quote)loop=asyncio.get_event_loop()# Creates the event looploop.run_until_complete(main())# Runs the event loopEnvironmentI suggest utilizing a .env file to store private/sensitive information.If you are not providing a refresh token, it is recommended that you use auth.Auth.manual_auth() in order to use
Ameritrade's front end auth tools, you can follow the on-screen instructions for this.You may choose to save your refresh token in a secure location/format, if using a previous refresh token, you only
need to provide these to your auth class:consumer_keyrefresh_tokenDevelopemntInstall dependencies with poetrypoetry install.Building Locallypoetry build
|
amer-seg
|
Failed to fetch description. HTTP Status Code: 404
|
amer-seg-2
|
Failed to fetch description. HTTP Status Code: 404
|
amersham
|
AmershamAmersham:The name of a London Underground station which alliterates with "argument parser"MotivationEvery CLI application wants two things:Sanitized user inputDescriptive usage and help messagesAmersham implements both with minimal boilerplate.Quick StartInstallpip3 install amershamImportimportsysfromamershamimportParserCreate a parser and commandparser=Parser("app")@parser.command()defcommand(parameter,flag=None):passRun the parserif__name__=="__main__":parser.run(sys.argv[1:])Run your programuser:~$ python3 app.py --help
usage
app.py [--help] [--flag] PARAMETER
flags
--help -h displays this message
--flag
parameters
PARAMETER stringAdvanced UsageMore Descriptive Help MessagesAdd some context to our command and argumentsoverrides={"description":"a command","parameter":{"description":"a parameter",},"flag":{"description":"a flag","alias":"f",}}@parser.command(**overrides)defcommand(parameter,flag=""):passAnd see the resultsuser:~$ python3 app.py --help
usage
app.py [--help] [--flag] PARAMETER
description
a command
flags
--help -h displays this message
--flag string a flag
parameters
PARAMETER string a parameter
|
ames
|
amesAutomated Metadata ServiceManage metadata from different sources. The examples in the package are
specific to Caltech repositories, but could be generalized. This package
is currently in development and will have additional sources and matchers
added over time.Basic InstallYou need to have Python 3.7 on your machine
(Minicondais a great
installation option).If you just need the python functions to write your own code
(like codemeta_to_datacite) open a terminal and typepip install amesFull InstallYou need to have Python 3.7 on your machine
(Minicondais a great
installation option). Test whether you have python installed by opening a terminal or
anaconda prompt window and typingpython -V, which should print version 3.7
or greater.Clone amesIt's best to download this software using git. To install git, typeconda install gitin your terminal or anaconda prompt window. Then find where you
want the ames folder to live on your computer in File Explorer or Finder
(This could be the Desktop or Documents folder, for example). Typecdin anaconda prompt or terminal and drag the location from the file browser into
the terminal window. The path to the location
will show up, so your terminal will show a command likecd /Users/tmorrell/Desktop. Hit enter. Then typegit clone https://github.com/caltechlibrary/ames.git. Once you
hit enter you'll see an epxml_to_datacite folder. Typecd amesInstallNow that you're in the ames folder, typepython setup.py install. You can
now run all the different operations described below.UpdatingWhen there is a new version of the software, go to the ames
folder in anaconda prompt or terminal and typegit pull. You shouldn't need to re-do
the installation steps unless there are major updates.OrganizationHarvesterscrossref_refs - Harvest references in datacite metadata from crossref event datacaltechdata - Harvest metadata from CaltechDATAcd_github - Harvest GitHub repos and codemeta files from CaltechDATAmatomo - Harvest web statistics from matomocaltechfeeds - Harvest Caltech Library metadata from feeds.library.caltech.eduMatcherscaltechdata - Match content in CaltechDATAupdate_datacite - Match content in DataCiteExample OperationsThe run scripts show examples of using ames to perform a specific update
operation.CodeMeta managementIn the test directory these is an example of using the codemeta_to_datacite
function to convert a codemeta file to DataCite standard metdataCodeMeta UpdatingCollect GitHub records in CaltechDATA, search for a codemeta.json file, and
update CaltechDATA with new metadata.CodeMeta SetupYou need to set an environmental variable with your token to access
CaltechDATAexport TINDTOK=CodeMeta UsageTypepython run_codemeta.py.CaltechDATA Citation AlertsHarvest citation data from the Crossref Event Data API, records in
CaltechDATA, match records, update metadata in CaltechDATA, and send email to
user.Citation Alerts SetupYou need to set environmental variables with your token to access
CaltechDATAexport TINDTOK=and Mailgunexport MAILTOK=.Citation Alerts UsageTypepython run_event_data.py. You'll be prompted for confirmation if any
new citations are found.Media UpdatesUpdate media records in DataCite that indicate the files associated with a DOI.Media SetupYou need to set an environmental variable with your password for your DataCite
account usingexport DATACITE=Media UsageTypepython run_media_update.py.CaltechDATA metadata checksThis will run checks on the quality of metadata in CaltechDATA. Currently this
verifies whether redundent links are present in the related identifier section.It also can update metadata with DataCite.Metadata Checks SetupYou need to set environmental variables with your token to access
CaltechDATAexport TINDTOK=Metadata Checks UsageTypepython run_caltechdata_checks.py.CaltechDATA Metadata UpdatesThis will improve the quality of metadata in CaltechDATA. This option is
broken up into updates that should run frequently (currently every 10 minutes)
and daily. Frequent updates include adding a recommended citation to the
descriptions, and daily updates include adding CaltechTHESIS DOIs to
CaltechDATA.Metadata Updates SetupYou need to set environmental variables with your token to access
CaltechDATAexport TINDTOK=Metadata Updates UsageTypepython run_caltechdata_updates.pyorpython run_caltechdata_daily.py.CaltechDATA COUNTER Usage ReportsThis will harvest download and view information from matomo and format it into
a COUNTER report. This feature is still being tested.Usage Report SetupYou need to set environmental variables with your token to access
Matomoexport MATTOK=Usage Report UsageTypepython run_usage.py.Archives ReportsRuns reports on ArchivesSpace. Current reports:accession_report: Returns accession records that match a certain subjectformat_report: Returns large report on accessions with certain media formatsExample usage:python run_archives_report.py accession_report accession.csv -subject "Manuscript Collection"Update EprintsPerform update options using the Eprints API. Supports url updates to https for
resolver field, special character updates, and adjusting the item modified date
(which also regenerates the public view of the page).Example usage:python run_eprints_updates.py update_date authors -recid 83420 -user tmorrell -passwordCODA ReportsRuns reports on Caltech Library repositories. Current reports:doi_report: Records (optionally filtered by year) and their DOIs.thesis_report: Matches Eprints tsv export for CaltechTHESISthesis_metadata: Matches Eprints metadata tsv export for CaltechTHESIScreator_report: Finds records where an Eprints Creator ID has an ORCID
but it is not included on all records. Also lists cases where an author has
two ORCIDS.creator_search: Export a google sheet with the author lists of all
publications associated with an author id. Requires -creator argumentpeople_search: Search across the CaltechPEOPLE collection by divisionfile_report: Records that have potential problems with the attached filesstatus_report: Reports on any records with an incorrect status in feedsrecord_number_report: Reports on records where the record number and resolver
URL don't matchalt_url_report: Reports on records with discontinure alt_url fieldlicense_report: Report out the license types in CaltechDATAReport UsageType something likepython run_coda_report.py doi_report thesis report.tsv -year 1977-1978The first option is the report typeNext is the repository (thesis or authors)Next is the output file name (include .csv or .tsv extension, will show up in current directory)Report OptionsSome reports include a -year option to return just the records from a specific year (1977) or a
range (1977-1978)Some reports include a -group option to return just the records with a
specific group name. Surround long names with quotes (e.g. "Keck Institute for Space Studies")Some reports include a -item option to return just records with a
specific item type. Supported types include:CaltechDATA item types (Dataset, Software, ...)CaltechAUTHORS item types (article, monograph, ...)CaltechAUTHORS monograph sub-typesdiscussion_paperdocumentationmanualotherproject_reportreporttechnical_reportwhite_paperworking_paperThere are some additional technical arguments if you want to change the default behavior.Adding-source eprintswill pull report data from Eprints instead of feeds. This is
very slow. You may need to add -username and -password to provide login
credentialsAdding-sample XXXallows you to select a number of randomly selected records. This makes it
more reasonable to pull data directly from Eprints.You can combine multiple options to build more complex queries, such as this
request for reports from a group:python run_coda_report.py doi_report authors keck_tech_reports.csv -group "Keck Institute for Space Studies" -item technical_report project_report discussion_paperpython run_coda_report.py people_search people chem.csv -search "Chemistry and Chemical Engineering Division"
|
amesh
|
No description available on PyPI.
|
ames-model
|
Trained regression model for the ames dataset
|
amet
|
# AmetAmet is a Python 2/3 library to read and write complex configuration from and to environment variables.## MotivationSome time ago I had to deploy an application to Heroku. This meant that I had to read the application's configuration from environment variables instead of the JSON files I was previously using for configuration. I wrote this library so that I could dump those configuration files into environment variables that I could easily read and assemble back into the original structure.This means that you do not need to give up the benefits of using a structured JSON file while using environment variables for configuration.## How to useFirst of all, install the library with a simple `pip install amet`.### Loading - The `load_from_environment` functionWhen loading a configuration object from the environment, the first thing that is needed is, of course, to define what needs to be read. The first thing we need to create is a dictionary to hold our configuration values as well as specify what type each value is. We will call this dictionary our prototype:```pythonCONFIGURATION_PROTOTYPE = {'database': {'hostname': str,'port': int,'username': str,'password': str,'use_ssl': bool}}```In order to load configuration values from environment variables, the `load_from_environment` function is provided. This function will iterate over our prototype and read environment variables that can be used to fill it. The format of the environment variables that are read can be customized by setting the `prefix` and `separator` string values and the `force_uppercase` boolean value`load_from_environment(proto, prefix='', force_uppercase=True, separator='_')`The environment variables that will be read are expected to have a particular format:`<prefix><separator><key-1><separator>...<key-n>`where `key-1` through `key-n` correspond to the keys of nested dictionaries. If `force_uppercase` is set, the environment variables will be converted to uppercase.For example, out previously defined configuration prototype would be filled with the value from the following environment variables (assuming `prefix` is left empty, `separator` is `_` and `force_uppercase` is `True`):* `DATABASE_HOSTNAME`* `DATABASE_PORT`* `DATABASE_USERNAE`* `DATABASE_PASSWORD`* `DATABASE_USE_SSL``load_from_environment` will always return a new dictionary, the prototype will remain unchanged.### Conversion of valuesAmet will attempt to convert values to Python primitive types. If the value for a given key is of type `int`, `float`, or `bool` (or the types themselves), upon reading the corresponding environment variables, Amet will attempt to parse those values. If the type of the value is `str` or `NoneType` the read value if left as is (which is `str`).In the previous example, `database.hostname` is assumed to be a string, however, `database.password` will be converted to `int` as that is the value given to that key. If a number such as `0` or `1` had been set then the value of `integer` would have also been converted.```pythonCONFIGURATION_PROTOTYPE = {'database': {'hostname': str, # Read as str'port': int, # Read as int'username': None, # Read as str'password': None, # Read as str'use_ssl': bool # Read as bool}}```Possible values for `True` are `T`, `True`, `TRUE`, `true`, `Y`, `Yes`, `YES`, `yes` and `1`. The same goes for `False`.### Writing - The `dump` functionThe `dump` function is also provided.`dump(config, prefix='', force_uppercase=True, separator='_')`This function will return a dictionary of the key-value pairs that should be set as environment variables. If we called `dump` with the dictionary in the previous example, the output would be:```python{`DATABASE_HOSTNAME`: ...`DATABASE_PORT`: ...`DATABASE_USERNAE`: ...`DATABASE_PASSWORD`: ...`DATABASE_USE_SSL`: ...}```### ExceptionsWhen a problem occurs loading or dumping a dictionary, errors may be raised.* `IncompatibleTypeError`, a subclass of `TypeError` will be raised if a key in the dictionary is not a `str` object or if a value is not a `dict`, `str`, `int`, `float` or `bool` value.* `KerError` is raised if an environment variable cannot be read.* `ValueError` is raised if a value cannot be parsed, for example if an integer is expected but the value is a string not corresponding to a number.## TODO- [x] Improve this README.- [ ] Add some useful examples for `dump` such as setting those variables in Heroku.- [ ] Add support for default values.spell- [ ] Check for possible name clashes when loading or dumping variables.- [ ] Improve unit tests.## ContributingIf you find any issues feel free to report them [here](https://github.com/maurodec/amet/issues/new). If you want you can also fork the project and submit a pull request.
|
amethyst
|
AmethystA general-purpose keyboard-centric launcher with a radial menu.Please read theAmethyst documentationfor more information about Amethyst, how to use it and how to contribute.
|
amethyst-core
|
A sober python base library for python 3. (Full Documentation)Caution!EXPERIMENTAL CODE. The interface to this library is not yet
stable. At this time, improvements will be made to the interface without
regard to backward compatibility. Backward-incompatible changes will not
necessarily be documented in the changelog, and changes may be added
which eat your puppy.A Generic Serializable ObjectThe primary product of this module is a base python object class designed
for easy serialization. JSON serialization and de-serialization come for
free for attributes of (most of the) core python object types.A Basic Class:fromamethyst.coreimportObject,AttrclassMyObject(Object):foo=Attr(int)bar=Attr(isa=str).strip()myobj=MyObject(foo="23")print(myobj.foo+1)# => 24Validation / CoersionclassMyObject(Object):amethyst_verifyclass=False# don't check json for class namefoo=Attr(int)# coerce to intbar=Attr(isa=str).strip()# ensure str then strip whitespaceValidatedconstructorsmyobj=MyObject({"foo":"23","bar":"Hello "})myobj=MyObject(foo="23",bar="Hello ")print(isinstance(myobj.foo,int))# Trueprint(myobj.bar)# "Hello"assignmentmyobj["foo"]="23"# Converts to intmyobj["foo"]="Not an int"# Raises exceptionmyobj.foo="23"# Converts to intmyobj.foo="Not an int"# Raises exceptionset and update methodsmyobj.set("foo",value)# Convert to int or raise exceptionmyobj.update(foo=value)# Convert to int or raise exceptionmyobj.setdefault("foo",value)# Convert or raise only if foo unsetloading fresh from dict or json# Converts and trimsmyobj.load_data({"foo":"23","bar":"Hello "})# Converts and trimsmyobj=MyObject.newFromJSON('{"foo": "23", "bar": "Hello "}')myobj.fromJSON('{"foo": "23", "bar": "Hello "}')Not Validatedmyobj.direct_set("foo","Not an int")# DANGER: Not an exception!myobj.direct_update(foo="Not an int")# DANGER: Not an exception!SerializationJSON text can be produced and loaded, even for nested objects.json_string=myobj.toJSON()myobj2=MyObject.newFromJSON(json_string)Other serialization libraries can easily be used as well.yaml_string=yaml.dump(myobj.deflate_data())myobj2=MyObject.inflate_new(yaml.safe_load(yaml_string))By default the JSON serializer injects type hints to ensure that objects
are de-serialized into the correct class:# print(MyObject(foo=23, bar="plugh").toJSON()){"__class__":"__mymodule.MyObject__","foo":23,"bar":"plugh"}When building an object from JSON, the constructor will look for these
hints and raise a ValueError if the type hint is missing or imported into
the wrong class.# These raise ValueErrorMyObject.newFromJSON('{"foo":23, "bar":"plugh"}')MyObject.newFromJSON('{"__class__": "__mymodule.MyOtherObject__", "foo":23}')Class verification can be skipped by passingverifyclass=Falseto the loader.myobj=MyObject.newFromJSON('{"foo":23, "bar":"plugh"}',verifyclass=False)If you want no munging or class verification at all, set the class parameters:classMyObject(Object):amethyst_includeclass=Falseamethyst_verifyclass=Falsefoo=Attr(int)bar=Attr(isa=str).strip()# No extra class info due to modified defaults:myobj=MyObject.newFromJSON('{"foo":"23", "bar":"plugh"}')print(myobj.toJSON())# => { "foo": 23, "bar": "plugh" }Ecosystem integrationWorks withsqlite3.Rowobjects:importsqlite3conn=sqlite3.connect(myfile)conn.row_factory=sqlite3.Rowforrowinconn.execute('SELECT * FROM mytable')obj=MyObject(row)...Works withsix.iteritems():importsixfork,vinsix.iteritems(myobj):...
|
amey-ml
|
amey_mlOverviewamey_ml is a versatile Python machine learning package providing a range of algorithms for different kinds of data processing and machine learning tasks. It includes implementations of popular algorithms such as Naive Bayes, Linear Regression, Neural Networks using Keras, Decision Trees, K-Nearest Neighbors, and K-Means Clustering. This package is designed to be user-friendly, efficient, and easily integrable into data analysis pipelines.InstallationTo install amey_ml, simply run the following command:pipinstallamey_mlFeaturesamey_ml includes the following modules and functions:Naive Bayes (naive_bayes.py)output(training_file, test_file): Perform Naive Bayes classification.Linear Regression (linear_regression.py)output(training_file, test_file, degree, lambda1): Perform regularized linear regression.Neural Networks with Keras (nn_keras.py)output(directory, dataset, layers, units_per_layer, epochs): Train and evaluate neural network models.Decision Trees (decision_tree.py)output(train_path, test_path, model_type, threshold): Train decision trees or random forests.K-Nearest Neighbors (knn_classify.py)output(training_file, test_file, k): Implement K-nearest neighbors classification.K-Means Clustering (k_means.py)output(data_file, K, initialization): Perform K-means clustering on a dataset.Each function is designed to be straightforward to use, requiring only the necessary parameters for each specific algorithm.Installing this package will install scikit-learn, tensorflow, pandas, scikit-learn, and keras by default.UsageTo use amey_ml, first import the required function from the package and then call it with the necessary parameters. Here are some example usages:fromamey_mlimportnaive_bayes,linear_regression,nn_kerasfromamey_mlimportdecision_tree,knn_classify,k_means# Naive Bayesnaive_bayes.output('training_data.csv','test_data.csv')# Linear Regressionlinear_regression.output('train.csv','test.csv',2,0.01)# Neural Networks using Kerasnn_keras.output('data_directory/','dataset_name',3,64,10)# Decision Treesdecision_tree.output('train_data.csv','test_data.csv','optimized',0.05)# K-Nearest Neighborsknn_classify.output('train.csv','test.csv',5)# K-Means Clusteringk_means.output('data.csv',3,'random')DocumentationEach function in the amey_ml package comes with detailed docstrings explaining the functionality,parameters, and return types. For more detailed documentation, refer to the docstrings within each function.ContributingContributions to amey_ml are welcome! If you'd like to contribute, please contact me [email protected]. Please fork the repository and use afeature branch. Pull requests are warmly welcome.LicensingThe code in this project is licensed under MIT license.GitHubhttps://github.com/Pistonamey/amey_ml/
|
ameypdf
|
This is the homepage of my project.
|
amf
|
Automated Modelling Framework
Makes ML simplier
|
amfi-get-data
|
Failed to fetch description. HTTP Status Code: 404
|
amfi-india-scraper-test
|
No description available on PyPI.
|
amfiprot
|
Amfiprot is a communication protocol for embedded devices used and developed by Amfitech. The protocol can be extended with plugins for specific devices implementing the Amfiprot protocol (e.g. the AmfiTrack).PrerequisitesPython 3.6 or higher.libusbin order to communicate with USB devices throughpyusbInstallationWindowsGet a libusb Windows binary fromhttps://libusb.info/. From the downloaded archive, copy the following two files:VS2015-x64\dll\libusb-1.0.dlltoC:\Windows\System32VS2015-Win32\dll\libusb-1.0.dlltoC:\Windows\SysWOW64Install (or update)amfiprotwithpip:pipinstall-UamfiprotLinux (Ubuntu)Installlibusb:sudoaptinstalllibusb-1.0-0-devMake sure that your user has access to USB devices. For example, give theplugdevgroup access to USB devices by creating a udev rule:echo'SUBSYSTEM=="usb", MODE="660", GROUP="plugdev"'|sudotee/etc/udev/rules.d/50-pyusb.rules
sudoudevadmcontrol--reload
sudoudevadmtriggerCheck whether you are a member ofplugdevwith:groups<username>If not, add yourself to the group with:sudousermod-aGplugdev<username>Finally, install (or update)amfiprotwithpip:pipinstall-UamfiprotQuick startThe basic workflow when using the library is:Create aConnectionto a device connected directly to the host machine (we call this the "root node").Search forNodes on theConnection(i.e. nodes connected through the root node)Create aDeviceusing one of the discoveredNodes.Start theConnection.Communicate with theDevice.Example:importamfiprotVENDOR_ID=0xC17PRODUCT_ID=0xD12if__name__=="__main__":conn=amfiprot.USBConnection(VENDOR_ID,PRODUCT_ID)nodes=conn.find_nodes()print(f"Found{len(nodes)}node(s).")fornodeinnodes:print(f"[{node.tx_id}]{node.name}")dev=amfiprot.Device(nodes[0])conn.start()cfg=dev.config.read_all()whileTrue:ifdev.packet_available():print(dev.get_packet())The following sections provide a more in-depth explanation.Discovering and connecting to a root nodeAfter attaching a device to your host machine, you can scan for connected devices (e.g. connected via USB) with:phys_devs=amfiprot.USBConnection.discover()fordevinphys_devs:print(dev)A connection can then be created using a specific physical device:conn=amfiprot.USBConnection(dev['vid'],dev['pid'],dev['serial_number'])Usingserial_numberis optional. If none is given, the first device matching the given vendor and product ID is used.Finding nodesAfter creating a connection, we can search for nodes that are connected to the root node (e.g. via RF or UART):nodes=conn.find_nodes()find_nodes()returns a list ofNodeinstances. ANodeprovides a low-level interface to the physical device and can be used to retrieve theuuid,tx_idandnameof the device, and send/receive raw packets. It is not recommended to use theNodedirectly, but rather attach it to aDeviceinstance.Creating a deviceADeviceis an abstraction layer on top of aNodeand is created by injecting aNodein the constructor:dev=amfiprot.Device(node)TheDeviceprovides a higher-level interface allowing the user to easily:Update the firmwareReboot the deviceRead/write configurationsRead decoded packetsWe are still able to access theNodethrough theDeviceif necessary:tx_id=dev.node.tx_idStarting the connection and interacting with the deviceBefore interacting with theDevice, theConnectionmust be started:conn.start()This creates a child process that asynchronously sends and receives packets on the specified interface. We can now interact with theDevicein the main process without worrying about blocking:device_name=dev.name()print(f"Reading packets from{device_name}...")whileTrue:ifdev.packet_available():print(dev.get_packet())We can access the device configuration through aConfiguratorinstance which is automatically created as a member (dev.config) of theDevice:# Read the entire configuration as a JSON-like object (a list of dicts)cfg=dev.config.read_all()# Print all parametersforcategoryincfg:print(f"CATEGORY:{category['name']}")forparameterincategory['parameters']:print(parameter)The configuration can be easily saved to and loaded from a.jsonfile:importjson# Write configuration to filewithopen("config.json","w")asoutfile:json.dump(cfg,outfile,indent=4)# Read configuration from file and send to devicewithopen("config.json","r")asinfile:new_cfg=json.load(infile)dev.config.write_all(new_cfg)Contributions and bug reportingThe Amfiprot Python package is open-source and the source code can be found on ourGithub repository. Contributions can be made through pull requests to thedevelopmentbranch. Bug reports and feature requests can be created in theIssuestab.
|
amfiprot-amfitrack
|
AmfiTrack extensions for theAmfiprotpackage.InstallationInstall (or update) withpip:pipinstall-Uamfiprot-amfitrackUsage exampleInstead of creating a genericamfiprot.Device, create anamfitrack.Deviceto get access to AmfiTrack specific functionality and payload interpretation:importamfiprotimportamfiprot_amfitrackasamfitrackVENDOR_ID=0xC17PRODUCT_ID_SENSOR=0xD12PRODUCT_ID_SOURCE=0xD01if__name__=="__main__":conn=Nonetry:conn=amfiprot.USBConnection(VENDOR_ID,PRODUCT_ID_SENSOR)except:try:conn=amfiprot.USBConnection(VENDOR_ID,PRODUCT_ID_SOURCE)except:print("No Amfitrack device found")exit()nodes=conn.find_nodes()print(f"Found{len(nodes)}node(s).")fornodeinnodes:print(f"[{node.tx_id}]{node.name}")dev=amfitrack.Device(nodes[0])conn.start()cfg=dev.config.read_all()dev.calibrate()whileTrue:ifdev.packet_available():packet=dev.get_packet()iftype(packet.payload)==amfitrack.payload.EmfImuFrameIdPayload:payload:amfitrack.payload.EmfImuFrameIdPayload=packet.payloadprint(payload.emf)else:print(packet)
|
amfm
|
UNKNOWN
|
amfpy
|
# amfpyamfpy provides Action Message Format(AMF) support for python3.### AMF SpecificationAMF 0 Specification: [pdf](http://wwwimages.adobe.com/content/dam/Adobe/en/devnet/amf/pdf/amf0-file-format-specification.pdf)AMF 3 Specification: [pdf](http://wwwimages.adobe.com/content/dam/Adobe/en/devnet/amf/pdf/amf-file-format-spec.pdf)
|
amfpy-python
|
Absolute Molecule File library extension for python. Absolute Molecule File (*.amf) is a specific kind of a filetype that allows people to create molecules and proteins easily. You can access the documentation fromhere
|
amf-rotary-valve
|
amf-rotary-valveThis Python package provides control ofAMF rotary valves.Installation$pipinstallamf-rotary-valve# List available devices$python-mamf_rotary_valveUsagefromamf_rotary_valveimportAMFDevicedevice=AMFDevice(address="COM3")device=AMFDevice(address="/dev/tty.usbmodem1101")asyncwithdevice:awaitdevice.home()valve_count=awaitdevice.get_valve_count()current_valve=awaitdevice.get_valve()# Rotate to the next valveawaitdevice.rotate(current_valve%valve_count+1)forinfoinAMFDevice.list():asyncwithinfo.create()asdevice:print(awaitdevice.get_unique_id())
|
amg
|
No description available on PyPI.
|
amget
|
No description available on PyPI.
|
am-get
|
No description available on PyPI.
|
amg-player
|
Angry Metal Guy PlayerAngry Metal Guy Player (AMG Player) is a Python multi platform console tool to automatically play or download tracks fromAngry Metal Guyreviews.I created this because:I like Angry Metal Guy, and discovered great music (both metal and totally non-metal) thanks to their reviewsI often disagree with their ratings (in fact I disagree more often than I agree), both for overrating and underratingEven when I disagree, I like reading their reviewsI want to listen to the musicbeforeI read the review, to avoid getting influencedTo be efficient, I want to listen to the tracks like a radio, and read the review to learn more only when I like somethingFeaturesCan work either in interactive mode (manually select tracks) or totally automatic (play new tracks like a radio)Supports embedded tracks from: YouTube, Bandcamp, SoundCloud, ReverbNationPlays YouTube video if available, or generates a video on the fly with the cover image + audio track(s) (requires FFmpeg)Can download tracks (with embedded album art) to play laterScreenshotsSelection screen:Playing a track:InstallationAngry Metal Guy Player requiresPython>= 3.7.
Some features are only available ifFFmpeg>= 2.8 is installed.From PyPI (with PIP)If you don't already have it,install pipfor Python 3Install Angry Metal Guy Player:pip3 install amg-playerFrom sourceIf you don't already have it,install setuptoolsfor Python 3Clone this repository:git clone https://github.com/desbma/amg-playerInstall Angry Metal Guy Player:python3 setup.py installAngry Metal Guy Player only supportsMPV playerfor now.Command line usageRunamg -hto get full command line reference.ExamplesBrowse and play interactively last 50 reviews:amg -c 50Choose the first track to play, then play all tracks in chronological order:amg -m radioPlay last 20 tracks in chronological order, skipping those already played:amg -c 20 -m discoverLicenseGPLv3
|
aMGSIM
|
Ancient metagenome simulation of multiple synthetic communities
See README for more information.
|
amharic-english-processor
|
Failed to fetch description. HTTP Status Code: 404
|
amharic-keyboard
|
Amharic-keyboardThis is a simple python package that lets you type Amharic letters using Latin alphabet.It will analyze the given Latin text for consonants + vowels and converts those words in to the equaivalent of Amharic words.It follws the same pattern used for typing Amharic words when texting.Installation:pip install amharic-keyboardor simply grab keyboard.py and import that.usageimport amharic_keyboard as ak
print(ak.type("selam nachihu?"))
#prints:
ሰላም ናችሁ?
|
amhelpers
|
amhelpersA collection of handy utilities.Installation$pipinstallamhelpersLicenseamhelperswas created by Anton Matsson. It is licensed under the terms of the MIT license.Creditsamhelperswas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
|
amhhandler
|
变更记录1.2.6mysqlfix: return type is None, which has no attribute 'lower'1.2.5mysql调整脚本代码调整doc1.2.4mysql新增参数判断清理test数据
|
ami
|
No description available on PyPI.
|
ami2py
|
ami2pyPython Package for reading and writing from and to an amibroker database.This package is using construct for defining the binary structures used to access the amibroker database,
seeConstruct documentation.The specification of the binary structure was taken from the official amibroker C++ sdk api documentation.However, this is not an official amibroker database api.Therefore, no warranty is given and handle with care.Improvement requests are always welcome.This module can be used to create a database and write symbol data to that.However, it seems to be a good idea to use the official quote downloader program for productive usage.ExamplesCreating a Database from scratch and adding symbol data to the database.
To use the underlying constructs in compiled form, use_compiled can be set to True within theAmiDataBase constructor. This is a more or less experimental feature.>>> from ami2py import AmiDataBase, SymbolEntry
>>> db = AmiDataBase(db_folder)
>>> db.add_symbol("AAPL")
>>> db.append_data_to_symbol(
"AAPL",
SymbolEntry(
Close=200.0,
High=230.0,
Low=190.0,
Open=210.0,
Volume=200003122.0,
Month=12,
Year=2020,
Day=17,
),
)
>>> db.write_database()Reading a list of symbols contained in the database.>>> symbols = db.get_symbols()
>>> symbols
["AAPL"]Getting values for a symbol in a pandas compatible dicitonary format.>>> db.get_dict_for_symbol("SPCE")
{
"Open": [20.0,....],
"Close": [200.0,....],
"High": [230.0,.....],
"Low": [190.0,.....],
"Open": [210.0,.......],
"Volume": [200003122.0,.....],
"Month": [12,.......],
"Year": [2020,.......],
"Day": [17,........],
}Using a list container facade for fast reading of symbol data.
The previous mentioned methods to read symbol data from the database use construct to
convert the binary array into a hierarchical object structure.
Creating those objects during the load process, causes high delay during loading.
Therefore a symbol facade called AmiSymbolDataFacade was created to read data only in case
it is necessary.>>> data = db.get_fast_symbol_data("SPCE")
>>> data[0]
{'Year': 2017,
'Month': 9,
'Day': 29,
'Hour': 10,
'Minute': 63,
'Second': 63,
'MilliSec': 258,
'MicroSec': 255,
'Reserved': 1,
'Isfut': 1,
'Close': 10.100000381469727,
'Open': 10.5,
'High': 10.5,
'Low': 10.0,
'Volume': 212769.0,
'AUX1': 0.0,
'AUX2': 0.0,
'TERMINATOR': 0.0
}
>>> newslice=data[0:10]
>>> newslice[0]
{'Year': 2017,
'Month': 9,
......
}
>>> newslice[1]
{'Year': 2017,
'Month': 10,
......
}TodosWrite tests for intraday data, currently data structures is able to handle intraday data.
But no tests had been written, until now.
This is considered mandatory to reach version 1.0.0Add docstrings to the source code. This seems to be a minor task.
|
ami2rabbitmq
|
AMI2RabbitMQOverviewIs a consumer of events produced by the Asterisk Manager Interface, where it organizes endpoints, bridges and queues into entities, persisting the last state on a redis server and producing an event for a queue on a RabbitMQ server.The generated data is persisted on the Redis Server with keys starting with the prefixOnline:< SUFIX >.DependenciesIt is necessary to have Redis, RabbitMQ, Asterisk installed and configured to use the lib.Installing AMI2RabbitMQ and Supported VersionsAMI2RabbitMQ is available on PyPI:$ python -m pip install ami2rabbitmqAMI2RabbitMQ officially supports Python 3.8+.Cloning the repositoryhttps://github.com/tatianno/ami2rabbitmq.gitExamplesSimple producer applicationfrom ami2rabbitmq import AMI2RabbitMQ
AMI_SETTINGS = {
'host' : 'localhost',
'user' : 'user',
'password' : 'password'
}
RABBITMQ_SETTINGS = RABBITMQ_SETTINGS = {
'host' : 'localhost',
'user' : 'user',
'password' : 'password',
'queuename' : 'online'
}
producer = AMI2RabbitMQ(
ami_settings = AMI_SETTINGS,
rabbitmq_settings = RABBITMQ_SETTINGS,
)
producer.run()Advanced producer applicationfrom ami2rabbitmq import AMI2RabbitMQ
AMI_SETTINGS = {
'host' : 'localhost',
'user' : 'user',
'password' : 'password'
}
RABBITMQ_SETTINGS = RABBITMQ_SETTINGS = {
'host' : 'localhost',
'user' : 'user',
'password' : 'password',
'queuename' : 'online'
}
class CustomProducerApp(AMI2RabbitMQ):
def update_events(self):
'''
The change_entities variable receives a list containing the entities that received state change events.
Entities can be of the type:
- Bridge : Call established between two endpoints
- QueueCaller : Call waiting in a queue
- Endpoint : Can be an extension or trunk
- QueueMember : Member of a queue
- Queue : Service queue
Entities are available for import:
import from ami2rabbitmq.entities import Bridge, Endpoint, QueueCaller, QueueMember, Queue
'''
change_entities = self._pabx.update(self.last_events)
self._send_change_to_broker(change_entities)
custom_producer = CustomProducerApp(
ami_settings = AMI_SETTINGS,
rabbitmq_settings = RABBITMQ_SETTINGS,
)
custom_producer.run()
|
amiadmin
|
A function to check if the user is an adminTested against Windows 10 / Python 3.10 / Anacondapip install amiadminfromamiadminimportam_i_adminprint(am_i_admin())True
|
amiami
|
Amiami APIA simple api wrapper around the amiami site.Simple usage can be something likeimportamiamiresults=amiami.search("fumofumo plush")foriteminresults.items:print("{},{}".format(item.productName,item.availability))Sometimes items tend to result in an unknown status because the flag -> state parsing is a bit rough. These items will be added to the list with a status ofUnknown status?. They will also print out a message with the flags and item code. Good to check your log and see what's going on.
|
amiandopy
|
amiandoPy makes it really easy to interact with amiando’s API
|
amibaker
|
This tool creates temporary hosts, allows temporary access, provisions it, creates an image from it, configures the image, cleans up, and give you an AMI ID.
|
amibo.py
|
Failed to fetch description. HTTP Status Code: 404
|
amibuilder
|
No description available on PyPI.
|
ami-builder-api
|
No description available on PyPI.
|
ami-builder-core
|
No description available on PyPI.
|
amical
|
(ApertureMaskingInterferometryCalibration andAnalysisLibrary)Installation$python3-mpipinstallamicalWhat can AMICAL do for you ?AMICAL is developed to provide an easy-to-use solution to processApertureMaskingInterferometry (AMI) data from major existing
facilities:NIRISSon the JWST (first scientific interferometer operating in space),SPHEREandVISIRfrom
the European Very Large Telescope (VLT) andVAMPIRESfrom SUBARU telescope (and more to come).We focused our efforts to propose a user-friendly interface, though different
sub-classes allowing to (1)Cleanthe reduced datacube from the standard
instrument pipelines, (2)Extractthe interferometrical quantities
(visibilities and closure phases) using a Fourier sampling approach and (3)Calibratethose quantities to remove the instrumental biases.In addition (4), we include two external packages calledCANDIDandPymasktoanalysethe final
outputs obtained from a binary-like sources (star-star or star-planet). We
interfaced these stand-alone packages with AMICAL to quickly estimate our
scientific results (e.g., separation, position angle, contrast ratio, contrast
limits, etc.) using different approaches (chi2 grid, MCMC, seeexample_analysis.pyfor details).Getting startedLooking for a quickstart into AMICAL? You can go through ourtutorialexplaining
how to use its different features.You can also have a look to the example scripts
made forNIRISSandSPHEREor get details about the CANDID/Pymask uses withexample_analysis.py.⚡ Last updates (08/2022) : New example script for IFS-SPHERE data is now availablehere.Use policy and reference publicationIf you use AMICAL in a publication, we encourage you to properly cite the
reference paper published during the 2020 SPIE conference:The James Webb Space
Telescope aperture masking
interferometer.
The library explanation is part of a broader description of the interferometric
mode of NIRISS, so feel free to have a look at the exciting possibilities of
AMI!AcknowledgementsThis work is mainly a modern Python translation of the very well known (and old)
IDL pipeline used to process and analyze Sparse Aperture Masking data. This
pipeline, called "Sydney code", was developed by a lot of people over many
years. Credit goes to the major developers, including Peter Tuthill, Mike
Ireland and John Monnier. Many forks exist across the web and the last IDL
version can be foundhere.
|
amici
|
Advanced Multilanguage Interface for CVODES and IDASAboutAMICI provides a multi-language (Python, C++, Matlab) interface for theSUNDIALSsolversCVODES(for ordinary differential equations) andIDAS(for algebraic differential equations). AMICI allows the user to read
differential equation models specified asSBMLorPySBand automatically compiles such models into Python modules, C++ libraries or
Matlab.mexsimulation files.In contrast to the (no longer maintained)sundialsTBMatlab interface, all necessary functions are transformed into native
C++ code, which allows for a significantly faster simulation.Beyond forward integration, the compiled simulation file also allows for
forward sensitivity analysis, steady state sensitivity analysis and
adjoint sensitivity analysis for likelihood-based output functions.The interface was designed to provide routines for efficient gradient
computation in parameter estimation of biochemical reaction models, but
it is also applicable to a wider range of differential equation
constrained optimization problems.Current build statusFeaturesSBML importPySB importGeneration of C++ code for model simulation and sensitivity
computationAccess to and high customizability of CVODES and IDAS solverPython, C++, Matlab interfaceSensitivity analysisforwardsteady stateadjointfirst- and second-orderPre-equilibration and pre-simulation conditionsSupport fordiscrete events and logical operationsInterfaces & workflowThe AMICI workflow starts with importing a model from eitherSBML(Matlab, Python),PySB(Python),
or a Matlab definition of the model (Matlab-only). From this input,
all equations for model simulation
are derived symbolically and C++ code is generated. This code is then
compiled into a C++ library, a Python module, or a Matlab.mexfile and
is then used for model simulation.Getting startedThe AMICI source code is available athttps://github.com/AMICI-dev/AMICI/.
To install AMICI, first read the installation instructions forPython,C++orMatlab.
There are also instructions for using AMICI insidecontainers.To get you started with Python-AMICI, the best way might be checking out thisJupyter notebook.To get started with Matlab-AMICI, various examples are available
inmatlab/examples/.Comprehensive documentation is available athttps://amici.readthedocs.io/en/latest/.Anycontributionsto AMICI are welcome (code, bug reports, suggestions for improvements, ...).Getting helpIn case of questions or problems with using AMICI, feel free to post anissueon GitHub. We are trying to
get back to you quickly.Projects using AMICIThere are several tools for parameter estimation offering good integration
with AMICI:pyPESTO: Python library for
optimization, sampling and uncertainty analysispyABC: Python library for
parallel and scalable ABC-SMC (Approximate Bayesian Computation - Sequential
Monte Carlo)parPE: C++ library for parameter
estimation of ODE models offering distributed memory parallelism with focus
on problems with many simulation conditions.PublicationsCiteable DOI for the latest AMICI release:There is a list ofpublications using AMICI.
If you used AMICI in your work, we are happy to include
your project, please let us know via a GitHub issue.When using AMICI in your project, please citeFröhlich, F., Weindl, D., Schälte, Y., Pathirana, D., Paszkowski, Ł., Lines, G.T., Stapor, P. and Hasenauer, J., 2021.
AMICI: High-Performance Sensitivity Analysis for Large Ordinary Differential Equation Models. Bioinformatics, btab227,DOI:10.1093/bioinformatics/btab227.@article{frohlich2020amici,
title={AMICI: High-Performance Sensitivity Analysis for Large Ordinary Differential Equation Models},
author={Fr{\"o}hlich, Fabian and Weindl, Daniel and Sch{\"a}lte, Yannik and Pathirana, Dilan and Paszkowski, {\L}ukasz and Lines, Glenn Terje and Stapor, Paul and Hasenauer, Jan},
journal = {Bioinformatics},
year = {2021},
month = {04},
issn = {1367-4803},
doi = {10.1093/bioinformatics/btab227},
note = {btab227},
eprint = {https://academic.oup.com/bioinformatics/advance-article-pdf/doi/10.1093/bioinformatics/btab227/36866220/btab227.pdf},
}When presenting work that employs AMICI, feel free to use one of the icons indocumentation/gfx/,
which are available under aCC0license:
|
amico
|
# amicoRelationships (e.g. friendships) backed by Redis. This is a port of the [amico gem](https://github.com/agoragames/amico).## Installationpip install amicoMake sure your redis server is running! Redis configuration is outside the scope of this README, but
check out the [Redis documentation](http://redis.io/documentation).## UsageBe sure to import the Amico library:`python from amico import Amico `Amico is configured with a number of defaults:`python >>> Amico.DEFAULTS {'namespace': 'amico', 'pending_follow': False, 'reciprocated_key': 'reciprocated', 'followers_key': 'followers', 'pending_with_key': 'pending_with', 'following_key': 'following', 'page_size': 25, 'pending_key': 'pending', 'blocked_by_key': 'blocked_by', 'default_scope_key': 'default', 'blocked_key': 'blocked'} `The initializer for Amico takes two optional parameters:options: Dictionary of updated defaultsredis_connection: Connection to Redis`python >>> amico = Amico(redis_connection = redis) ``python >>> amico.follow(1, 11) >>> amico.is_following(1, 11) True >>> amico.is_following(11, 1) False >>> amico.follow(11, 1) >>> amico.is_following(11, 1) True >>> amico.following_count(1) 1 >>> amico.followers_count(1) 1 >>> amico.unfollow(11, 1) >>> amico.following_count(11) 0 >>> amico.following_count(1) 1 >>> amico.is_follower(1, 11) False >>> amico.following(1) ['11'] >>> amico.block(1, 11) >>> amico.is_following(11, 1) False >>> amico.is_blocked(1, 11) True >>> amico.is_blocked_by(11, 1) True >>> amico.unblock(1, 11) >>> amico.is_blocked(1, 11) False >>> amico.is_blocked_by(11, 1) False >>> amico.follow(11, 1) >>> amico.follow(1, 11) >>> amico.is_reciprocated(1, 11) True >>> amico.reciprocated(1) ['11'] `Use amico (with pending relationships for follow):`python >>> amico = Amico(options = {'pending_follow': True}, redis_connection = redis) >>> amico.follow(1, 11) >>> amico.follow(11, 1) >>> amico.is_pending(1, 11) True >>> amico.is_pending_with(11, 1) True >>> amico.is_pending(11, 1) True >>> amico.is_pending_with(1, 11) True >>> amico.accept(1, 11) >>> amico.is_pending(1, 11) False >>> amico.is_pending_with(11, 1) False >>> amico.is_pending(11, 1) True >>> amico.is_pending_with(1, 11) True >>> amico.is_following(1, 11) True >>> amico.is_following(11, 1) False >>> amico.is_follower(11, 1) True >>> amico.is_follower(1, 11) False >>> amico.accept(11, 1) >>> amico.is_pending(1, 11) False >>> amico.is_pending_with(11, 1) False >>> amico.is_pending(11, 1) False >>> amico.is_pending_with(1, 11) False >>> amico.is_following(1, 11) True >>> amico.is_following(11, 1) True >>> amico.is_follower(11, 1) True >>> amico.is_follower(1, 11) True >>> amico.is_reciprocated(1, 11) True >>> amico.follow(1, 12) >>> amico.is_following(1, 12) False >>> amico.is_pending(1, 12) True >>> amico.deny(1, 12) >>> amico.is_following(1, 12) False >>> amico.is_pending(1, 12) False `All of the calls support ascopeparameter to allow you to scope the calls to express relationships for different types of things. For example:`python >>> amico = Amico(options = {'default_scope_key':'user'},redis_connection = redis) >>> amico.follow(1, 11) >>> amico.is_following(1, 11) True >>> amico.is_following(1, 11, scope = 'user') True >>> amico.following(1) ['11'] >>> amico.following(1, scope = 'user') ['11'] >>> amico.is_following(1, 11, scope = 'project') False >>> amico.follow(1, 11, scope = 'project') >>> amico.is_following(1, 11, scope = 'project') True >>> amico.following(1, scope = 'project') ['11'] `You can retrieve all of a particular type of relationship using theall(id, type, scope)call. For example:`python >>> amico.follow(1, 11) >>> amico.follow(1, 12) >>> amico.all(1, 'following') ['12', '11'] `typecan be one of ‘following’, ‘followers’, ‘blocked’, ‘blocked_by’, reciprocated’, ‘pending’ and ‘pending_with’. Use this with caution as there may potentially be a large number of items that could be returned from this call.You can clear all relationships that have been set for an ID by callingclear(id, scope). You may wish to do this if you allow records to be deleted and you wish to prevent orphaned IDs and inaccurate follower/following counts. Note that this clearsallrelationships in either direction - including blocked and pending. An example:`python >>> amico.follow(11, 1) >>> amico.block(12, 1) >>> amico.following(11) ['1'] >>> amico.blocked(12) ['1'] >>> amico.clear(1) >>> amico.following(11) [] >>> amico.blocked(12) [] `## FAQ?### Why use Redis sorted sets and not Redis sets?Based on the work I did in developing [leaderboard](https://github.com/agoragames/leaderboard),
leaderboards backed by Redis, I know I wanted to be able to page through the various relationships.
This does not seem to be possible given the current set of commands for Redis sets.Also, by using the “score” in Redis sorted sets that is based on the time of when a relationship
is established, we can get our “recent friends”. It is possible that the scoring function may be
user-defined in the future to allow for some specific ordering.## Contributing to amicoCheck out the latest master to make sure the feature hasn’t been implemented or the bug hasn’t been fixed yetCheck out the issue tracker to make sure someone already hasn’t requested it and/or contributed itFork the projectStart a feature/bugfix branchCommit and push until you are happy with your contributionMake sure to add tests for it. This is important so I don’t break it in a future version unintentionally.Please try not to mess with the version or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.## CopyrightCopyright (c) 2013 David Czarnecki. See LICENSE.txt for further details.
|
amiconn
|
No description available on PyPI.
|
am-i-connected
|
am_i_connectedThis python3 package is the simplest way to check if there is internet connection.you can install this library usingpip.pip install am_i_connectedexample of use:fromam_i_connectedimportcheckasthere_is_internetifthere_is_internet():print('You are connected! Amazing!')else:print("Hey, you aren't connected...")
|
amicrt
|
AMI-CRTAdditional mutual information conditional randomization testsInstallation guidepip install amicrt
|
amicus-interfaces
|
No description available on PyPI.
|
amid
|
Awesome Medical Imaging Datasets (AMID) - a curated list of medical imaging datasets with unified interfacesGetting startedJust import a dataset and start using it!Note that for some datasets you must manually download the raw files first.fromamid.verseimportVerSeds=VerSe()# get the available idsprint(len(ds.ids))i=ds.ids[0]# use the available methods:# load the image and vertebrae masksx,y=ds.image(i),ds.masks(i)print(ds.split(i),ds.patient(i))# or get a namedTuple-like object:entry=ds(i)x,y=entry.image,entry.masksprint(entry.split,entry.patient)Available datasetsNameEntriesBody regionModalityAMOS360AbdomenCT, MRIBIMCVCovid1916335ChestCTBraTS20215880HeadMRI T1, MRI T1Gd, MRI T2, MRI T2-FLAIRCC359359HeadMRI T1CLDetection2023400HeadX-rayCRLM197AbdomenCT, SEGCT_ICH75HeadCTCrossMoDA484HeadMRI T1c, MRI T2hrDeepLesion20094Abdomen, ThoraxCTEGD3096HeadFLAIR, MRI T1, MRI T1GD, MRI T2FLARE20222100AbdomenCTLIDC1018ChestCTLiTS201AbdominalCTLiverMedseg50Chest, AbdomenCTMIDRC155ThoraxCTMOOD1358Head, AbdominalMRI, CTMedseg99ChestCTMoscowCancer500979ThoraxCTMoscowCovid11101110ThoraxCTNLST13624ThoraxCTNSCLC422ThoraxCTRSNABreastCancer54710ThoraxMGStanfordCoCa971Coronary, ChestCTTotalsegmentator1204Head, Thorax, Abdomen, Pelvis, LegsCTUPENN_GBM671HeadFLAIR, MRI T1, MRI T1GD, MRI T2, DSC MRI, DTI MRIVSSEG484HeadMRI T1c, MRI T2VerSe374Thorax, AbdomenCTCheck outour docsfor a more detailed list of available datasets and their fields.InstallJust get it from PyPi:pipinstallamidOr if you want to use version control features:gitclonehttps://github.com/neuro-ml/amid.gitcdamid&&pipinstall-e.ContributeCheck ourcontribution guideif you want to add a new dataset to
AMID.
|
amidala
|
amidalaThis is a placeholder for the package amidala. This package analyzes data collected from evaluating strategies that mitigate the phase ordering problem.
|
amieci
|
amieciThe python client for amie.ai.Install withpip install amieciDocumentationA tutorial notebook to get you started ishere.More notebooks that show you how to integrate amie in your measurement and data-science workflowshere.InstallationSign up (free) onwww.amie.aiand obtain an API key after you're logged in underwww.amie.ai/#/userThen sign in from python, and load the garden.garden = amieci.Garden(key=your_key)
garden.load()
...The fundamental object in amie is the garden. It contains all trees and leaves and remembers how your data interconnects.Every day, valuable data and results get lost and forgotten. amie provides you with an easy way to structure and store your results. It does not only store your data,
but also their relationships, to make sure your workflow is fully reproducible and make it easy for you to keep an overview.
amie works with any data-driven task, from data-science to beer brewing.
|
amieclient
|
amieclientPython library for the AMIE REST APISeethe docsfor API documentation.Seeexamplesfor examples of usage
|
ami-encrypter
|
Failed to fetch description. HTTP Status Code: 404
|
amieraser
|
UNKNOWN
|
amifast
|
amifast: simple powerful benchmarking with PythonContents:Installation and usage|Contributing|Change Log|AuthorsInstallation and UsageInstallationUsageExamplesExamples can be found in theExamplesdirectory.Command line optionsWill be added at a later date.LicenseMITContributingMore details can be found inCONTRIBUTINGChange LogNothing has been recorded here so far...AuthorsDeveloped byJulian Niedermeier
|
amIFat
|
Python Package ExerciseA little exercise to create a Python package, build it, test it, distribute it, and use it. Seeinstructionsfor details.DescriptionOfficial DocumentationThis is a lightweight, health-focused package that offers the following functionality:Calculates a user’s Body Mass Index determines where the user falls within the BMI scale, ranging from underweight to obeseIdentifies diseases associated with a certain, abnormal BMI level (underweight or overweight)Describes a balanced diet consisting of the amount, in grams, of proteins, carbohydrates, fat, sugar, saturated fats, as well as food energy in caloriesCalculates a user’s Active Metabolic Rate, with an option for the user to get his/her Basal Metabolic Rate.FeaturesCalculate a user's BMI and render obesity scale:howfat(age, height, weight, scale):
//Returns bmi score, scale
/More details about parameters:
* age - integer value representing age
* height - numeric value representing height
* metric - float value in (cm)
* imperial - float value in (in)
* weight- numeric value representing weight
* metric - float value in (kg)
* imperial - float value in (lbs)
* scale
* "i" for imperial
* "m" for metric
/Disclosure:
BMI and its respective obesity scale may not reflect a precise overview of one's health conditions, especially for ages under 18 and above 65.Return list of related diseases by BMI:fat_problems(bmi):
//Returns related diseasesCalculate a user's recommended daily calorie intake:calories(age, gender, height, weight, activityLevel, scale):
//Returns recommended daily calorie intake
/More details about parameters
* age - integer value representing age
* gender
* "f" for female
* "m" for male
* height - numeric value representing height
* metric - float value in (cm)
* imperial - float value in (in)
* weight - numeric value representing weight
* metric - float value in (kgs)
* imperial - float value in (lbs)
* activityLevel- numeric value (integer) representing a user's activity level
Use scale below:
0-Basal Metabolic Rate
1-Sedentary: little or no exercise
2-Lightly active: exercise 1-3 times a week
3-Moderately active: exercise 3-5 times a week
4-Active: exercise 6-7 times a week
5-Very active: hard exercise 6-7 times a week
* scale
* "i" for imperial
* "m" for metricCalculate a user's resting energy expenditurecalculateREE(age, gender, height, weight, scale):
More details about parameters:
* age - integer value representing age
* gender
"f" for female
"m" for male
* height - numeric value representing height
* metric - float value in (cm)
* imperial - float value in (in)
* weight - numeric value representing weight
* metric - float value in (kgs)
* imperial - float value in (lbs)
* scale
* "i" for imperial
* "m" for metricCalculate a user's total daily energy expenditurecalculateTDEE(REE, userActivityLevel)
More details about parameters
* REE - Resting Energy Expenditure in calories (how many calories burned at rest)
* userActivityLevel- numeric value (integer) representing a user's activity level
Use scale below:
1 - Sedentary: Just everyday activities like a bit of walking, a couple of flights of stairs, eating, talking, etc. (REE X 1.2)
2 - Lightly active: Any activity that burns an additional 200-400 calories for females or 250-500 calories for males. (REE x 1.375)
3 - Moderately active: Any activity that burns an additional 400-650 calories for females or 500-800 calories for males. (REE x 1.55)
4 - Very Active: Any activity that burns an additional 650+ calories for females or 800+ calories for males. (REE x 1.725)Calculate a user's target TDEE for weight loss or gainweightLossOrGainCalculator(TDEE, lossOrGain)
More details about parameters
* weight - numeric value representing weight
q * metric - float value in (kgs)
* imperial - float value in (lbs)
* lossOrGain
* 'l' for loss - aiming to lose weight
* 'g' for gain - aiming to gain weight
* scale
* "i" for imperial
* "m" for metricCalculate ideal macronutrient ratios for a given weight and TDEEmacros(weight, targetTDEE, scale)
More details about parameters
* TDEE - total daily energy expenditure in calories (amount of energy your body burns in a day)
* lossOrGain
* 'l' for loss - aiming to lose weight
* 'g' for gain - aiming to gain weightHow to Install and Use this PackageNavigate to your desired root directory and executepipenv install -i https://pypi.org/simple/amIFat==1.1.0(Prof B's note: if you've previously created a pipenv virtual environment in the same directory, you may have to delete the old one first. Find out where it is located with the pipenv --venv command.)Activate virtual environment withpipenv shellCreate a python program in the directory and import all the functions in theamIFatpackage with//some imports you can make
from amIFat.macros import *
from amIFat.calories import *
from amIFat.howfat import *
from amIFat.fat_problems import *Install the amIFat package withpipenv install amifatensure that the package is installed in your pipenv withpip listImplement the functions in your program and run it withpython3 path/to/yourProgram.pyExit the virtual environment withexitHow to Run Example Apppython3 src/amIFatApp/app.pyAuthorsLee, BrianPointi, BhavigSeo, MishaTalgatuly, Sagynbek
|
amifinder
|
UNKNOWN
|
amifs_core
|
TODO
|
amigados-utils
|
amigados-utils - Command line utilities for Amiga system developmentDescriptionThis is a set of utilities to facilitate Amiga development in a Unix style
environment.amigados-dir - dir utility for ADF filesamigados-copy - copy utility for ADF filesamigados-makedir - makedir utility for ADF filesamigados-createdisk - utility for creating ADF/HDF filesamigados-fdtool - replacement for fd2pragma (just started)amigados-bumprev - replacement for BumpRevamigados-dalf - replacement for Dalf (Amiga binary file viewer)amigados-png2image - image converterInstallationpip install amigados-utilsReferencesROM Kernel Manuals:http://amigadev.elowar.com/ADF format:http://lclevy.free.fr/adflib/adf_info.html
|
amightygirl.paapi5-python-sdk
|
Product Advertising API 5.0 SDK for Python (v1)About This PackageThis repository contains the official Product Advertising API 5.0 Python SDK calledpaapi5-python-sdkthat allows you to access theProduct Advertising API.The code in this package was written entirely by Amazon.com. Based on the original documentation, it appears that Amazon originally intended to make this package available viapip; however, it appears that either (a) that never happened or (b) they removed it. We created this package to correct that.The only changes we made to Amazon's original package were:Modifying this README file to reflect the correct pip package informationModifying the setup.py fileDocumentation and Original SDKAmazon's documentation for the Product Advertising API can be found at:https://webservices.amazon.com/paapi5/documentation/index.htmlYou can download the original SDK from Amazon.com at:https://webservices.amazon.com/paapi5/documentation/quick-start/using-sdk.htmlRequirementsPython 2.7 and 3.4+Installation & Usagepip installYou can directly install it from pip using:pipinstallamightygirl.paapi5-python-sdkThen import the package:importpaapi5_python_sdkGetting StartedPlease follow theinstallation procedureand then run the following:Simple example forSearchItemsto discover Amazon products with the keyword 'Harry Potter' in All categories:from__future__importprint_functionfrompaapi5_python_sdk.api.default_apiimportDefaultApifrompaapi5_python_sdk.search_items_requestimportSearchItemsRequestfrompaapi5_python_sdk.search_items_resourceimportSearchItemsResourcefrompaapi5_python_sdk.partner_typeimportPartnerTypefrompaapi5_python_sdk.restimportApiExceptiondefsearch_items():""" Following are your credentials """""" Please add your access key here """access_key="<YOUR ACCESS KEY>"""" Please add your secret key here """secret_key="<YOUR SECRET KEY>"""" Please add your partner tag (store/tracking id) here """partner_tag="<YOUR PARTNER TAG>"""" PAAPI Host and Region to which you want to send request """""" For more details refer: https://webservices.amazon.com/paapi5/documentation/common-request-parameters.html#host-and-region"""host="webservices.amazon.com"region="us-east-1"""" API declaration """default_api=DefaultApi(access_key=access_key,secret_key=secret_key,host=host,region=region)""" Request initialization"""""" Specify keywords """keywords="Harry Potter"""" Specify the category in which search request is to be made """""" For more details, refer: https://webservices.amazon.com/paapi5/documentation/use-cases/organization-of-items-on-amazon/search-index.html """search_index="All"""" Specify item count to be returned in search result """item_count=1""" Choose resources you want from SearchItemsResource enum """""" For more details, refer: https://webservices.amazon.com/paapi5/documentation/search-items.html#resources-parameter """search_items_resource=[SearchItemsResource.IMAGES_PRIMARY_LARGE,SearchItemsResource.ITEMINFO_TITLE,SearchItemsResource.OFFERS_LISTINGS_PRICE,]""" Forming request """try:search_items_request=SearchItemsRequest(partner_tag=partner_tag,partner_type=PartnerType.ASSOCIATES,keywords=keywords,search_index=search_index,item_count=item_count,resources=search_items_resource,)exceptValueErrorasexception:print("Error in forming SearchItemsRequest: ",exception)returntry:""" Sending request """response=default_api.search_items(search_items_request)print("API called Successfully")print("Complete Response:",response)""" Parse response """ifresponse.search_resultisnotNone:print("Printing first item information in SearchResult:")item_0=response.search_result.items[0]ifitem_0isnotNone:ifitem_0.asinisnotNone:print("ASIN: ",item_0.asin)ifitem_0.detail_page_urlisnotNone:print("DetailPageURL: ",item_0.detail_page_url)if(item_0.item_infoisnotNoneanditem_0.item_info.titleisnotNoneanditem_0.item_info.title.display_valueisnotNone):print("Title: ",item_0.item_info.title.display_value)if(item_0.offersisnotNoneanditem_0.offers.listingsisnotNoneanditem_0.offers.listings[0].priceisnotNoneanditem_0.offers.listings[0].price.display_amountisnotNone):print("Buying Price: ",item_0.offers.listings[0].price.display_amount)ifresponse.errorsisnotNone:print("\nPrinting Errors:\nPrinting First Error Object from list of Errors")print("Error code",response.errors[0].code)print("Error message",response.errors[0].message)exceptApiExceptionasexception:print("Error calling PA-API 5.0!")print("Status code:",exception.status)print("Errors :",exception.body)print("Request ID:",exception.headers["x-amzn-RequestId"])exceptTypeErrorasexception:print("TypeError :",exception)exceptValueErrorasexception:print("ValueError :",exception)exceptExceptionasexception:print("Exception :",exception)search_items()Complete documentation, installation instructions, and examples are availablehere.LicenseThis SDK is distributed under theApache License, Version 2.0,
see LICENSE.txt and NOTICE.txt for more information.
|
amigo
|
No description available on PyPI.
|
amigocloud
|
Python client for theAmigoCloudREST
API.InstallationInstall via pip:pip install amigocloudDependenciesrequests: Handles the HTTP requests to the AmigoCloud REST API.gevent: Handles the websocket connections.socketIO_client: Handles the AmigoCloud websocket connection.six: A library to assit with python2 to python3 compatibility.This dependencies will be automatically installed.UsageAuthenticationThis library uses API token to authenticate you. To generate or access your API tokens, go toAPI tokens.fromamigocloudimportAmigoCloudamigocloud=AmigoCloud(token='R:dlNDEiOWciP3y26kG2cHklYpr2HIPK40HD32r1')You could also use a project token. Remember that project tokens can only be used to query endpoints relative to the project it belongs to.
If the project URL doesn’t match its project,AmigoCloudErrorwill be thrown.fromamigocloudimportAmigoCloudamigocloud=AmigoCloud(token='C:Ndl3xGWeasYt9rqyuVsByf5HPMAGyte10y1Mub',project_url='users/123/projects/1234')You can use a READ token if you only want to do requests that won’t alter data. Otherwise, you’ll need to use more permissive tokens.RequestsOnce you’re logged in you can start making requests to the server. You
can use full urls or relative API urls:# All three will do the same request:amigocloud.get('me')amigocloud.get('/me')amigocloud.get('https://www.amigocloud.com/api/v1/me')For convenience, when using project tokens, urls are relative to the project’s url (unless it starts with/):# All three will do the same request:amigocloud.get('datasets')amigocloud.get('/users/123/projects/1234/datasets')amigocloud.get('https://www.amigocloud.com/api/v1/users/123/projects/1234/datasets')Creating a new AmigoCloud project from Python is as simple as:data={'name':'New Project','description':'Created from Python'}amigocloud.post('me/projects',data)All responses are parsed as JSON and return a Python object (usually adict). This data can be later used in another request:me=amigocloud.get('me')visible_projects=amigocloud.get(me['visible_projects'])print'My projects:'forprojectinvisible_projects['results']:print'*',project['name']You can get the raw response if you want by using therawparameter:me=amigocloud.get('me')images=amigocloud.get(me['images'])withopen('thumbnail.png','wb')asthumbnail:image_data=amigocloud.get(images['thumbnail'],raw=True)thumbnail.write(image_data)Cursor RequestsMany requests return a paginated list. For example: projects, datasets, base layers,
and sql queries. They can be identified when the request returns a dictionary with
four items.fromamigocloudimportAmigoCloudamigocloud=AmigoCloud(token='yourapitoken')project_list=amigocloud.get('/me/projects')pprint(project_list)will return a dictionary like this (modified for brevity):{u'count':319,u'next':u'https://app.amigocloud.com/api/v1/me/projects?limit=20&offset=20&token=yourapitoken',u'previous':None,u'results':[]}From the results, you can see that this endpoint can be iterated through.
To make it easier to iterate through these lists, you can use theget_cursorfunction. The cursor iterates over the results and if it reaches the limit of
the response it will automatically make a request to get the next values. So
you can get all data and iterate over it, without worrying about the
pagination.projects=amigocloud.get_cursor('/me/projects')forprojectinprojects:print('Project:',project['name'])If you want to iterate one request at a time it can be requested as:# using a project token to authenticatedatasets=amigocloud.get_cursor('datasets')dataset1=datasets.next()print('Dataset1:',dataset1['name'])# Boolean to ask if there is a next value.# otherwise a StopIteration exception is raised.ifdatasets.has_next:dataset2=datasets.next()print('Dataset2:',dataset2['name'])Also, you can request some extra values, that are included in the response.dataset_rows=amigocloud.get_cursor('https://www.amigocloud.com/api/v1/projects/1234/sql',{'query':'select * from dataset_1'})print('Response extra values:',dataset_rows.get('columns'))forrowindataset_rows:print('Row:',row)Cursors can be used for Projects, Datasets, BaseLayers, SQL queries, etc.
It also supports non-iterable responses. For this cases it returns only one result.cursor=amigocloud.get_cursor('me')formeincursor:print('Me:',me)Websocket connectionThe websocket connection is started when the AmigoCloud object is
instantiated, and it is closed when the object is destroyed. You always
need to use a user token for websockets.Make sure to readour help page about our websocket eventsbefore continue reading.To start listening to websocket events related to your user (multicast
events), do (you must be logged in to start listening to your events):amigocloud.listen_user_events()Once you’re listening to your events, you can start adding callbacks to
them. A callback is a function that will be called everytime the event
is received. These functions should have only one parameter, that would be a python dict.defproject_created(data):print'User id=%(user_id)screated project id=%(project_id)s'%dataamigocloud.add_callback('project:creation_succeeded',project_created)Realtime events are broadcast events related to realtime dataset. To start listening to them, do:amigocloud.listen_dataset_events(owner_id,project_id,dataset_id)Then add a callback for them:defrealtime(data):print'Realtime dataset id=%(dataset_id)s'%dataforobjindata['data']:print"Object '%(object_id)s' is now at (%(latitude)s,%(longitude)s)"%objamigocloud.add_callback('realtime',realtime)Finally, start running the websocket client:ac.start_listening()This method receives an optional parameterseconds. IfsecondsisNone(default value), the client will listen forever. You might
want to run this method in a new thread.ExceptionsAnAmigoCloudErrorexception will be raised if anything fails during
the request:try:amigocloud.post('me/projects')exceptAmigoCloudErroraserr:print'Something failed!'print'Status code was',err.response.status_codeprint'Message from server was',err.text
|
amigrations
|
Ascetic MigrationsFor my personal projects I’d like to use raw sql migrations. Django for example generates ugly
key names: something like: key_numberInstallationSimply run in your bash:pipinstallamigrationsUsagefromamigratonsimportAMigrationsamigrations=AMigrations('mysql://root:123456@localhost:3306/amigrations_test',path_to_folder_with_migrations)files_created=amigrations.create(migraiton_message)# files_created is a dictionary with two keys: up and down. If you want immediately update migration content, please# do followingwithfiles_created['up'].open('w')asfpu,files_created['down'].open('w')asfpd:fpu.write('CREATE TABLE test (id int(11) not null AUTO_INCREMENT, PRIMARY KEY(id))')fpd.write('drop table test')# run db upgradeamigrations.upgrade()# please pass migration id you want to downgrade to, includingamigrations.downgrade_to(downgrade_to_id)
|
amiibo.py
|
amiibo.pyA powerfull, rich API Wrapper for amiiboapi.comFeatures100% API CoverageAsync/Sync versionsOptimized speedInstallationNote: Python 3.5.3 or higher is requiresInstall stable version:# if your os is macOS
> python3 -m pip install -U amiibo.py
# If your os is Windows
> py -3 -m pip install -U amiibo.pyInstall development version:> git clone https://github.com/XiehCanCode/amiibo.py
> cd amiibo.py
> python3 -m pip install .UsageA Quick example in Sync version:importamiiboclient=amiibo.Client()print(client.get_amiibos())A Quick example in Async version:importasyncioimportamiibodefmain():client=amiibo.AsyncClient()print(awaitclient.get_amiibos())loop=asyncio.get_event_loop()loop.run_until_complete(main())
|
amilatest
|
FoobarAmiLATEST is a dependency checker for your python project. It is a tool to help you find outdated dependencies, and generate a report that suggests upgrade possibilities at major, minor, and patch levels.AmiLATEST can be used as CLI or as a library.InstallationUse the package managerpipto install amilatest.pipinstallamilatestUsage as CLIThe CLI is a simple command line interface to AmiLATEST.
For basic usage, simply runamilatestwithin your project directory (where yourrequirements.txtis located). It will then check all those dependencies and generate a report.amilatestBy default the report is displayed on the terminal as a table. If you want to see the report in a processable format, you can use the--jsonflag.amilatest--jsonUsage as libraryAmiLATEST can also be integrated into your project as a library. To do so, you need to importAnalyzerclass from theamilatestmodule.fromamilatestimportAnalyzera=Analyzer('./requirements.txt')json_output=a.analyze()LimitationsCurrently AmiLATEST depends on thepip indexcommand, which comes with pip version 22 or higher.Editable requirements are not supported, so you can't use--editableflag. When usingpip freeze, you must
use the--exclude-editableflag to get rid of the editable requirements.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
|
amilstead-test-python
|
Failed to fetch description. HTTP Status Code: 404
|
am-imaging
|
No description available on PyPI.
|
amimspy
|
Python package for processing acoustic mist ionization mass spectrometry-based metabolomics and lipidomics dataDocumentation:https://amimspy.readthedocs.io/en/latestSource:https://github.com/computational-metabolomics/amimspyBug reports:https://github.com/computational-metabolomics/amimspy/issuesInstallationSee theInstallation pageof
theonline documentation.Bug reportsPlease report any bugs that you findhere.
Or fork the repository onGitHuband create a pull request (PR). We welcome all contributions, and we
will help you to make the PR if you are new togit.CreditsDevelopers and contributersMatthew Smith ([email protected]) -University of Birmingham (UK)Ralf J. M. Weber ([email protected]) -University of Birmingham (UK)AMIMSpy acknowledges support from the following funders:BBSRC and Waters Corporation for an iCASE PhD studentship.LicenseAMIMSpy is licensed under the GNU General Public License v3.0 (seeLICENSE filefor licensing information). Copyright © 2020 Matthew Smith, Ralf Weber
|
aminacadea
|
Project descriptionAminacadeaOverviewThe Aminacadea library is a dummy helper for tflite-model-maker for use in Google Colab. In Planning phase.RequirementsRefer to requirements.txt for dependent libraries that're needed to use the library and run the demo code.
Note that you might also need to install sndfile for Audio tasks. On Debian/Ubuntu, you can do so by sudo apt-get install libsndfile1InstallationpipinstallaminacadeaAminacadea depends on tflite-model-maker >=0.4.2, Pillow >=9.3.0https://packaging.python.org/en/latest/tutorials/packaging-projects/Generating distribution archivesGenerate distribution packages for the package. These are archives that are uploaded to the Python Package Index and can be installed by pip.
NOTE: Run as AdminstratorMake sure you have the latest version of PyPA’s build installed:python-mpipinstall--upgradebuildNow run this command from the same directory where pyproject.toml is located:python-mbuildThis command should output a lot of text and once completed should generate two files in the dist directory:Uploading the distribution archivesTo securely upload your project, you’ll need a PyPI API token.
Create one athttps://test.pypi.org/manage/account/#api-tokens, setting the “Scope” to “Entire account”.Now that you are registered, you can use twine to upload the distribution packages. You’ll need to install Twine:python-mpipinstall--upgradetwineCREATE .pypirc file in place it in %USERPROFILE%
5) Once installed, run Twine to upload all of the archives under dist:python-mtwineupload--repositorytestpypidist/*Once installed, run Twine to upload all of the archives under dist:python-mtwineupload--repositorypypidist/*Dependencies - TODOdependencies = [
"tflite-model-maker>=0.1.",
"tflite-support>=0.1.",
"Pillow==7.1.",
"matplotlib==3.2.",
]
|
aminDrain3
|
Failed to fetch description. HTTP Status Code: 404
|
aminebasiccalculator
|
this is a very simple calculator that takes two numbers and either add , substract ,multiply or divide them.Change log0.0.1(6/10/2020)First Release
|
amineparser
|
This is package for extracting specific informations from resumes written in both french and english languages, this package extracts personel informations, technical skills, certifications and qualifications .Change Log0.0.8 (12/09/2020)First Release
|
aminetoolkit
|
No description available on PyPI.
|
amine-utils
|
Example PackageThis is a simple example package. You can useGithub-flavored Markdownto write your content.
|
aminfo
|
No description available on PyPI.
|
aminimalreconciler
|
No description available on PyPI.
|
amino
|
No description available on PyPI.
|
aminoacid
|
This project is in no way associated with Amino or MediaLabs, this is completely reverse engineeredAminoAcidWhy AminoAcid?Because other projects likeBotAminofail to allow a nicely done, pythonic, completely async hinted experience.This project aims to open up the possibilities that other libraries don't fulfill by being completely async using aiohttp, allowing OOP, allowingeventswith a discord.py-esque experience.While BotAminotriesto be easy to use it fails to provide an easy high-level API by forcing to useAmino.fixinstead of allowing access via their own methods and objects.How do you use it?AminoAcid's documentation is available throughGitHub pagesand auto generated usingpdoc, for examples take a look intothe examples dirfromaminoacidimportBotfromaminoacid.abcimportMessage,Contextclient=Bot(prefix="b!",key=bytes.fromhex("B0000000B50000000000000000000B000000000B"),device="42...")@client.command(name="say")asyncdefhi(ctx:Context,*nya:str):message=awaitctx.send(" ".join(nya))print(message)@client.event("on_message")asyncdefon_message(message:Message):ifmessage.author.id==client.profile.id:returnprint(message,"nya!")client.run(session="AnsiMSI6...")# OR#client.run(# email="[email protected]",# password= r"Rc2Z=I5S0bN;ewjn2jasdn43",#)As you might see, you need to supply your own key to sign the requests with. You can find this in other libraries tho.Please note, that this library isNOTfinished and a lot of features I want to implement are still missing.How to subscribe to topics to get notifications?AminoAcid supports receiving notification events via the socket like the normal app would.The notification future still needs a lot of work, because so far it's not receiving events like follow, comment, etc.To receive notifications with a certain topic you can it's suggested to send a subscribe object in your on_ready [email protected]()asyncdefon_ready():client.logger.info(client._http.session)awaitclient.socket.subscribe(ndcId,topic=topic)...so far known topics are documented intheTopicsenumWhy no key?The aim of this library isNOTto make malicious bots, which is why you need to put the key in yourself.This library should only be used for making fun chat bots.How to do X?Check the docs, if it's in there then look at how to use it. If it's not there you probably can't.If you want to request a feature, you can open a new Issue.AminoAcid or AminoAcids?This was originally called AminoAcids but then i noticed that the pypi project "aminoacids" was already taken, so i removed the sTo-DoFinish Object attributesType checking and convertingAdd Embed featuresImprove existing featuresBetter quality in codeComplete ExceptionsComplete SocketCode EnumMake the SocketClient subscribe to other events to allow on_follow and on_notification eventsFinish started but unfinished methodsCog-like Command categorieson_typing_start, etc. events (socket code 400)Command error handlers
|
aminoacids
|
AminoAcidsWhat is this?AminoAcids is a python api for communicating with amino servers while pretending that you are an app user. This is mostly accomplished by spoofing device configuration headers, though actually generating those is still in progress. It is also for objectifying and organizing amino response data, so that actually doing anything is easier.Why is this?A member of the Coding101 Amino asked about a public Amino API, and that got my brain thinking. So, I decided to start making one as a fun project.How is this?As mentioned, this works largely by spoofing device info and login session keys in request headers. These were captured by using the Amino application an android client, and by usingCharlesto intercept request and API response data. If you'd like to do this for yourslef, youshould be using android 6 or earlierWho is this?This is currently being developed bymealone, though pull requests and issues are very much so welcome. You can contact me on Discord at Zero#5200 if you have any questions about the project, or for anything else.UsageDocuments are coming soon, when I have something to document. That being said, this is an unstable build and should not be relied on for much (the API will change!). If you'd still like to use it, all of the methods (should) contain docstrings with info to get you started.ContributingThis project is just starting (as of whenever this README is pushed), so there are no contributing guidelines yet. Feel free to poke around the source, and feel free to create a pull with some new features or fixes that you'd like to implement.
|
amino.ae
|
#https://discord.gg/NnKWCtY2F8
|
amino.api
|
Library InformationLibrary DocumentationLibrary in githubMore infoTelegram ChannelYouTube channelDiscord ServerLibrary for working with aminoapps servers, below you will see code examples, for more examples see the documentation or the examples folderLogin exampleimportaminoclient=amino.Client()client.login(email='email',password='password')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.