Saravanan666/pypi-org huggingface dataset:
Package: mke-sculib
.. highlight:: rst============================
mke_sculibMeerKAT Extension (MKE)
(SCU) Science Computation Unit interface (lib)rary for the MKE antennas and some basic simulatorsInstalling.. code-block:: bash
pip install mke-sculibUsage for Antenna Control:In order to connect to the REST API of the Telescope SCU use the library as follows:.. code-block:: python
from mke_sculib.scu import scu as scu_api
antenna_ip = '10.96.64.10'
scu = scu_api(ip='134.104.22.44', port='8080', debug = False)
print(scu)
print(scu.determine_dish_type())
print(scu.version_acu)Usage as Simulator:Using the simulator with the same script as used for operating the telescope can be
achieved like this:.. code-block:: python
from mke_sculib.sim import plot_motion_pyplot as plot_motioninstead of THIS:from mke_sculib.scu import scumpi = scu('134.104.22.44', '8080')do THIS for simulation:from mke_sculib.sim import scu_sim as scu
mpi = scu()After a test has been done, the whole test history can be plotted in pyplot via:.. code-block:: pythonshow the history datadfh = mpi.get_history_df(interval_ms = None)
axs = plot_motion(dfh)Using the library within Test Scripts:After installation, the library can be used to script automatic tests. A minimal
example for a tracking test is given below:.. code-block:: pythonInitimport astropy.units as u
from astropy.time import Time
import numpy as np
import pandas as pdimport matplotlib.pyplot as plt
from mke_sculib.sim import plot_motion_pyplot as plot_motion
from mke_sculib.sim import scu_sim as scumpi = scu()Startupmpi.unstow()
mpi.wait_duration(30) # sec
mpi.activate_dmc()
mpi.wait_duration(wait10)Move to starting az, elmpi.abs_azimuth(-90, 3) # degree, degree / s
mpi.abs_elevation(53, 1) # degree, degree / s
mpi.wait_settle()
mpi.wait_duration(5) # secmove to Band 2mpi.move_to_band('Band 2')
mpi.wait_settle()
mpi.wait_duration(wait5)make a dummy tracking tablet = mpi.t_internal + (np.arange(5) * astropy.units.u.s)
az = np.linspace(-90, -89, len(t))
el = np.linspace(53, 54, len(t))start a tracking tablempi.upload_track_table(t, az, el)start logging for my testrunmpi.start_logger('full_configuration')wait for track table to finishmpi.wait_duration(np.ptp(t) + 5)shut downmpi.stop_logger()
mpi.wait_duration(5)
mpi.deactivate_dmc()
mpi.wait_duration(10)
mpi.stow()show the sessions datadf = mpi.get_session_as_df(interval_ms = 100)
plot_motion(df)
df.to_csv('testdata_acu.csv')See alsoscriptsfor examples on how to use this libraryHTTP Dummy serverThis library has a dummy server with dashboard implemented which can run on any machine with anaconda installed.See:serversfor the examples.NOTE: Change the absolut path in the files if necessary.. code-block:: bash
python /servers/dashboard.py
Package: mkfbr
What is make_a_fake_brazilian A.K.A mkfbr? Where is he going? Where does he come from? What does it feed on?Well, this simple project was born out of a particular need in personal projects. Specifically I needed some information from Brazilians, such as: Name, Address, CPF, CPNJ, Age, among other things. Since then, I decided to make my job easier with a quick and simple to use module.Note:This project only serves as an object of study and/or software testing, do not use it for fraudulent activities.Quick note about missing states in the databaseThe database for this project was built based on data provided byCEP ABERTO, which in turn did not include (when >darkmathew< performed the scraping) the following states:Maranhão, Rio de Janeiro, Rio Grande do Norte, Roraima and Tocantins. I apologize to you if you need data generated from any of these regions of Brazil. If you get this information and want to share it with the project, please submit a properly tested and verified PR that includes cities and zip codes for those states.Install from PyPipip install mkfbrSimple UsagefrommkfbrimportMake_A_Fake_Brazilianmkfbr=Make_A_Fake_Brazilian()brazilian=mkfbr.get_brazilian()print(brazilian)Output example:{
    'name': 'Egídia Angelles',
    'age': 47,
    'birthday': '26/11/1975',
    'cpf': '80051493608',
    'rg': '136076262',
    'cnpj': '',
    'address': 'Rua Expedito Pereira de Souza 971',
    'state': 'Acre',
    'state_abbreviation': 'AC',
    'city': 'Bujari',
    'bairro': 'Centro',
    'logradouro': ''
}Generate Female PersonfrommkfbrimportMake_A_Fake_Brazilianmkfbr=Make_A_Fake_Brazilian(gender_name='F',)brazilian=mkfbr.get_brazilian()print(brazilian)Generate Male PersonfrommkfbrimportMake_A_Fake_Brazilianmkfbr=Make_A_Fake_Brazilian(gender_name='M',)brazilian=mkfbr.get_brazilian()print(brazilian)Generate CPNJ / RG / CPF with pontuationNote:To generate CNPJ thegen_cnpjargument needs to be true.frommkfbrimportMake_A_Fake_Brazilianmkfbr=Make_A_Fake_Brazilian(cpf_mode='points',rg_mode='points',gen_cnpj=True,cnpj_mode='points',)brazilian=mkfbr.get_brazilian()print(brazilian)Output example:{
    'name': 'Eros de Assuncao',

    'age': 66,

    'birthday': '15/01/1956',

    'cpf': '058.592.229-20',

    'rg': '57.137.420-4',

    'cnpj': '60.294.437/0001-07',

    'address': 'Avenida André Pereira Lobato, s/n',

    'state': 'Piauí',

    'state_abbreviation': 'PI',

    'city': 'Sebastião Barros',

    'bairro': 'Centro',

    'logradouro': ''

}
Package: mkflask_module
kickass_flask_template_module(KFT) version 0.1.01:Welcome and thank you for considering the KFT module. The purpose of this module is to streamline the process of starting a new project in flask.This project is aimed at students of python who are faced with starting new projects constantly in an effort to learn the framework and the in's and out's of python.For your convenience the KFT module works on both windows and *nix based systems. (Tested on Windows 8, OSX and Linux Mint)Usage is as follows:KFT is initialized from the command line, if you don't have Python installed in your path you will have to navigate to wherever python is installed to use it.KFT module will ask you a series of questions pertaining to your project. Simply answer with either a 1 or anything else. Inputs are configured to execute code based on input of either 1 or not 1, so anything besides 1 is considered "other".This module executes as it runs meaning once you've answered a question or two things get moving to create your project. Keep this in mind as you answer the questions because things will be happening in the background.KFT is capable of creating your base folder structure and any template pages you may need during your project. KFT will add routes in the server.py file for each page you choose to create in your templates.Have fun and thanks for using KFT module!
Package: mkgendocs
mkgendocsA Python package for automatically generating documentation pages in markdown for
Python source files by parsingGoogle style docstring. The markdown output makes it
ideal to combine withmkdocs.Instead of executing the python code (using theinspectpackage to access signatures and docstrings), we extract the information directly from the source files by parsing them into Abstract Syntax Trees (AST) using theastpackage.Theastor(AST observe/rewrite) package is also used to convert function or class signatures from AST nodes back into source code strings.InstallationInstall mkgendocs fromPyPIpipinstallmkgendocsUsagegendocs --config mkgendocs.ymlA sources directory is created with the documentation that was automatically generated.
Any examples in a "examples" directory are automatically copied over to the documentation,
the module level docstrings of any example source files are also copied and converted to markdown.Configuration Examplesources_dir:docs/sourcestemplates_dir:docs/templatesrepo:https://github.com/davidenunes/tensorx#link to sources on githubversion:master#link to sources on githubpages:-page:"api/train/model.md"source:"tensorx/train/model.py"methods:-Model:-train-set_optimizer-page:"api/layers/core.md"source:'tensorx/layers.py'classes:-Linear:-compute_shape-Module-page:"math.md"source:'tensorx/math.py'functions:-sparse_multiply_dense# creates an index page based on everything from target source-page:"api/layers/index.md"source:"tensorx/layers.py"index:Truesources_dir: directory where the resulting markdown files are createdtemplates_dir: directory where template files can be stored. All the folders and files are
copied to thesources_dir. Any markdown files are used as templates with the
tag{{autogenerated}}in the template files being replaced by the generated documentation.repo: repository to createview sourcelinks automatically for each class, function, and method;version: defaults to "master" to create link to sources in the formhttps://repo/blob/version/file.py/#L1425;pages: list of pages to be automatically generated from the respective source files and templates:page: path for page template / sources dir for the resulting page;source: path to source file from which the page is to be generated;classes: list of classes to be fully documented; a list of method names can be passed for each class, the default is
to generate all methods;functions: list of functions to be documented.index: if True creates an index page for the given sources, you can also specify classes and functions, but not methodsBuy me a coffeeIf you find any of this useful, consider getting me some coffee, coffee is great!
Package: mkgist
mkgistA small utility for making gists. When I need to share code snippets online, the formatting always ends up totally messed up when I copy-paste manually. This alleviates that.SetupWith pipThe easiest way to get a copy is throughpip3:pip3 install mkgistAnnoying things happen, at least on my system, withoutpip3. I'll look into it at some point.ManualTo install dependencies, runpip install -r requirements.txtafter installing. I don't use this within a virtual environment, but doing so would look something like this:virtualenv -p $(which python3) $HOME/virtualenv/mkgist
source $HOME/virtualenv/mkgist/bin/activateUsagemkgist filenames [-d "description"] [--public] [--raw] [--nocopy]If no filenames are entered, the contents of the gist are read from STDIN.The location of the created gist is printed to stdout.Gists are secret by default, but can be made public with--public. (Secret gists aren't indexed by search engines)--rawreturns a link to the raw hosted file, which you can then get withcurlorwget. If multiple files are created with this flag, the URLs are always printed to stdout.By default, the URL of the created Gist is copied to the clipboard.--nocopyprints the link to stdout instead, not overwriting the clipboard.
Package: mkgmap-pygments
A pygments lexer for mkgmap style filesThis package installs a new lexer for pygmentize to syntax highlightmkgmapstyle files.  You can then use pygmentize (or the API) with the
lexer ‘mkgmap’ to highlight style files.Installing this package will install pygments if it not already
installed:pip install mkgmap-pygmentsUsageTo just display a file to the terminal:pygmentize -l mkgmap linesTo create a complete html file:pygmentize -l mkgmap -f html -Ofull=true -o output.html linesStyleThe package also includes a pygments style namedmkgmap.You might prefer it to the default style as it will be used in
the mkgmap manual and website.To create a complete html file using the mkgmap style:pygmentize -l mkgmap -f html -Ofull=true,style=mkgmap -o output.html lines
Package: mkhelp
MkHelpSupport for docstrings in makefilesSometimes it is convenient to use a makefile as interface to development workflows.
The recipes are flexible, can depend on other targets andmakeprovides tab completion.With the script provided by this package it is easy to also get a help message describing important make targets.
Look at the.DEFAULT_GOALandbin/print_makefile_help.pytargets in the makefile to see how to set it up.
Once set up it could look something like$ make
Verbs:
 help: Print help message

Checks:
    check_all: Run all checks that have not yet passed
 check_format: Check format
   check_lint: Check lint
   check_dist: Check that distribution can be built and will render correctly on PyPi
   check_docs: Check that documentation can be built
   check_diff: Check that there are no untracked git changes
  check_tests: Check that unit tests pass
    check_tox: Check that unit tests pass in multiple environments
  check_types: Check types

Fixes:
 fix_format: Fix format

Nouns:
 bin/print_makefile_help.py: Update the script that generates the help message for this makefile
      build/docs/index.html: Build this documentationOne additional feature of this package is to export the docstrings in the makefile to other formats allowing them to be included in documentation.
Look at thebuild/docs/index.htmltarget in the makefile to see how to set it up.
Once set up it could look something like the makefile page in the docs of this project.
Package: mkie
mkieA useful tool for control clis in terminal.InstallationIf you already know how to install python packages, then you can install it via pip.pip3 install mkieUpgradepip3 install --upgrade mkieFeaturesmkieis control clis:Gitgitadd: Auto add all files to git and ignore submodules.gitfetch: Sort out local branchs.gitpull: Pull latest update from git repo.s: Swap current branch to target branch.Dockerdps: list docker containersdbu: build docker containerdup: start docker contrainerdd: stop docker containerdrun: exec docker container
Package: mkignore
mkignoreGenerate .gitignore from templatesInstallationpip install mkignoreUsagemkignore[-h][-g,--generate][-u,--update][-l,--list][TEMPLATES[TEMPLATES...]]Generate.gitignorefiles

positionalarguments:TEMPLATES

optionalarguments:-h,--helpshowthishelpmessageandexit-g,--generateGenerate.gitignore-u,--updateUpdateavailable.gitignoretemplates-l,--listListavailable.gitignoretemplatesExampleGenerate a .gitignore for a C++ project in a JetBrains IDE.mkignore -g c++ jetbrains > .gitignore
Package: mkimgproxy
Generates URL for imgproxy image processing serverUse following command line to generate IMGPROXY_KEY and IMGPROXY_SALTecho$(xxd-g2-l64-p/dev/random|tr-d'\n')frommkimgproxyimportImgProxyIMGPROXY_URL="http://my-imgproxy-server/path"IMGPROXY_KEY="9cbc4f564037858e5b9f2304f8540aa606943bddeaecb00a0b4a498092d0d65c079e291d3a2ddceafd23f1a29bb914fbf91a8464515826bb6a9f609800781182"IMGPROXY_SALT="3dae9fbe7138431c57d59625d19175901df23786b1b8b6c65a39a0ac26f344809478bb3c7f6a838a1a45dbe123f85a16d8ce74c2f595cbf61d12a8470c588201"imgProxy=ImgProxy(IMGPROXY_KEY,IMGPROXY_SALT,IMGPROXY_URL)resizedImageUrl=imgProxy.generate("http://example.com/images/curiosity.jpg",{"s":"800:500","rt":"fit","g":"sm","q":70,"sm":"true"},"jpeg")print(resizedImageUrl)
Package: mkite-catalysis
mkite_catalysismkite_catalysisis a plugin to run catalysis-related recipes with mkite.
As of now, the plugin has the following recipes implemented: surface cutting, supercell generation, and combinatorial adsorption, implemented with the help ofpymatgen.DocumentationGeneral tutorial formkiteand its plugins are available in themain documentation.
Complete API documentation is pending.InstallationTo installmkite_catalysis, use pip:pipinstallmkite_catalysisAlternatively, for a development version, clone this repo and install it in editable form:pipinstall-Ugit+https://github.com/mkite-group/mkite_catalysisContributionsContributions to the entire mkite suite are welcomed.
You can send a pull request or open an issue for this plugin or either of the packages in mkite.
When doing so, please adhere to theCode of Conductin the mkite suite.The mkite package was created by Daniel Schwalbe-Kodadskoda@llnl.gov.Citing mkiteIf you use mkite in a publication, please cite the following paper:@article{mkite2023,title={mkite: A distributed computing platform for high-throughput materials simulations},author={Schwalbe-Koda, Daniel},year={2023},journal={arXiv:2301.08841},doi={10.48550/arXiv.2301.08841},url={https://doi.org/10.48550/arXiv.2301.08841},arxiv={2301.08841},}LicenseThe mkite suite is distributed under the following license: Apache 2.0 WITH LLVM exception.All new contributions must be made under this license.SPDX: Apache-2.0, LLVM-exceptionLLNL-CODE-848161
Package: mkite-conformer
mkite_conformermkite_conformeris a plugin to generate molecular conformers usingRDKit.
The plugin has only one recipe implemented: generating and deduplicating conformers.DocumentationGeneral tutorial formkiteand its plugins are available in themain documentation.
Complete API documentation is pending.InstallationTo installmkite_conformer, use pip:pipinstallmkite_conformerAlternatively, for a development version, clone this repo and install it in editable form:pipinstall-Ugit+https://github.com/mkite-group/mkite_conformerContributionsContributions to the entire mkite suite are welcomed.
You can send a pull request or open an issue for this plugin or either of the packages in mkite.
When doing so, please adhere to theCode of Conductin the mkite suite.The mkite package was created by Daniel Schwalbe-Kodadskoda@llnl.gov.Citing mkiteIf you use mkite in a publication, please cite the following paper:@article{mkite2023,title={mkite: A distributed computing platform for high-throughput materials simulations},author={Schwalbe-Koda, Daniel},year={2023},journal={arXiv:2301.08841},doi={10.48550/arXiv.2301.08841},url={https://doi.org/10.48550/arXiv.2301.08841},arxiv={2301.08841},}LicenseThe mkite suite is distributed under the following license: Apache 2.0 WITH LLVM exception.All new contributions must be made under this license.SPDX: Apache-2.0, LLVM-exceptionLLNL-CODE-848161
Package: mkite-core
mkite-core: essentials for mkitemkite_core offers a set of tools for the mkite suite. For example, it provides essential classes for recipes, plugins, and midware for models. mkite_core also offers some I/O support for interfacing mkite with other packages, such as rdkit.DocumentationGeneral tutorial formkiteand its plugins are available in themain documentation.
Complete API documentation is pending.Installationmkite_coreis essential to run all other components of mkite. To install this package, use pip:pipinstallmkite_coreAlternatively, for a development version, clone this repo and install it in editable form:pipinstall-Ugit+https://github.com/mkite-group/mkite_coreContributionsContributions to the entire mkite suite are welcomed.
You can send a pull request or open an issue for this plugin or either of the packages in mkite.
When doing so, please adhere to theCode of Conductin the mkite suite.The mkite package was created by Daniel Schwalbe-Kodadskoda@llnl.gov.Citing mkiteIf you use mkite in a publication, please cite the following paper:@article{mkite2023,title={mkite: A distributed computing platform for high-throughput materials simulations},author={Schwalbe-Koda, Daniel},year={2023},journal={arXiv:2301.08841},doi={10.48550/arXiv.2301.08841},url={https://doi.org/10.48550/arXiv.2301.08841},arxiv={2301.08841},}LicenseThe mkite suite is distributed under the following license: Apache 2.0 WITH LLVM exception.All new contributions must be made under this license.SPDX: Apache-2.0, LLVM-exceptionLLNL-CODE-848161
Package: mkite-db
What is mkite?mkite is a suite of tools for running high-throughput materials simulations in distributed computing platforms.
The mkite suite decouples the production database from client workers, facilitating scaling of simulations across heterogeneous computing environments.
The infrastructure enables exploration of combinatorial materials spaces using workflows, recipes, data visualizations, and more.Some advantages of mkite:It stores and organizes complex materials workflows on databases. For example, mkite allows creating workflows with more than one parent input branch (say, interfaces between solids and molecules).The server is agnostic to the computing environments where the tasks are performed, and the clients are unaware of the production database. This facilitates distributing the tasks across heterogeneous computing systems.It provides textual descriptions for workflows, and enables adapting them on-the-fly. This helps as a "lab notebook" for computational materials scientists.It is adaptable to many software packages and inputs. The recipe system also interacts well with other libraries, such as ASE, pymatgen, cclib, and more.DocumentationGeneral tutorial formkiteand its plugins are available in themain documentation.
Complete API documentation is pending.InstallationTo installmkite_db, first installmkite_coreandmkite_engines.
Then, install this repository with pip:pipinstallmkite_coremkite_engines
pipinstallmkite_dbAlternatively, for a development version, clone this repo and install it in editable form:pipinstall-Ugit+https://github.com/mkite-group/mkite_dbContributionsContributions to the entire mkite suite are welcomed.
You can send a pull request or open an issue for this plugin or either of the packages in mkite.
When doing so, please adhere to theCode of Conductin the mkite suite.The mkite package was created by Daniel Schwalbe-Kodadskoda@llnl.gov.Citing mkiteIf you use mkite in a publication, please cite the following paper:@article{mkite2023,title={mkite: A distributed computing platform for high-throughput materials simulations},author={Schwalbe-Koda, Daniel},year={2023},journal={arXiv:2301.08841},doi={10.48550/arXiv.2301.08841},url={https://doi.org/10.48550/arXiv.2301.08841},arxiv={2301.08841},}LicenseThe mkite suite is distributed under the following license: Apache 2.0 WITH LLVM exception.All new contributions must be made under this license.SPDX: Apache-2.0, LLVM-exceptionLLNL-CODE-848161
Package: mkite-engines
mkite_enginesmkite_engines implements interfaces that help distributing jobs to workers.
These interfaces areproducers and consumersof data, and are created to simplify data management and transfer between the production server and the task worker.DocumentationGeneral tutorial formkiteand its plugins are available in themain documentation.
Complete API documentation is pending.Installationmkite_enginesis essential to run all other components of mkite. To install this package, use pip:pipinstallmkite_enginesAlternatively, for a development version, clone this repo and install it in editable form:pipinstall-Ugit+https://github.com/mkite-group/mkite_enginesContributionsContributions to the entire mkite suite are welcomed.
You can send a pull request or open an issue for this plugin or either of the packages in mkite.
When doing so, please adhere to theCode of Conductin the mkite suite.The mkite package was created by Daniel Schwalbe-Kodadskoda@llnl.gov.Citing mkiteIf you use mkite in a publication, please cite the following paper:@article{mkite2023,title={mkite: A distributed computing platform for high-throughput materials simulations},author={Schwalbe-Koda, Daniel},year={2023},journal={arXiv:2301.08841},doi={10.48550/arXiv.2301.08841},url={https://doi.org/10.48550/arXiv.2301.08841},arxiv={2301.08841},}LicenseThe mkite suite is distributed under the following license: Apache 2.0 WITH LLVM exception.All new contributions must be made under this license.SPDX: Apache-2.0, LLVM-exceptionLLNL-CODE-848161