Saravanan666/pypi-org huggingface dataset:
Package: ajayspackage
The README.md file in a Python package typically contains documentation that provides an overview of the package, its features, and how to use it. The file is written in Markdown format, which is a lightweight markup language that allows you to easily format text with headers, links, lists, and other elements.The README.md file is usually one of the first files that a user or developer will see when they visit the package's repository on GitHub or another hosting platform. It can be thought of as the "front page" of the package and serves as a quick reference for what the package does and how to use it.Here are some common sections that you might find in a README.md file for a Python package:Introduction: A brief introduction to the package and its purpose.
Installation: Instructions on how to install the package using pip or another method.
Quickstart: A simple example that demonstrates how to use the package.
Usage: Detailed instructions on how to use the package, including code examples and explanations of its features.
Contributing: Guidelines for how to contribute to the package, such as how to report issues or submit pull requests.
License: Information about the license under which the package is distributed.
The README.md file is an important component of a Python package's documentation, and it's a good idea to keep it up-to-date and informative to help users and developers get started with the package.
Package: ajc27-freemocap-blender-addon
Freemocap AdapterAdd-on to adapt the Freemocap Blender output. It can adjust the empties position, add a rig and a body mesh. The
resulting rig and animation can be imported in platforms like Unreal Engine.RequirementsActivate the Rigify add-on in Blender preferences.InstallationInstall as a regular *.py add-on in Edit->Preferences-Add-ons.Considerations:The rig has a TPose as rest pose for easier retargeting.
For best results, when the adjust empties function is executed the empties should be forming a standing still pose with
arms open similar to A or T Pose.
The body_mesh.ply file should be in the same folder as the Blender file before manually opening it.
Package: ajcli
example usage:$ jiracli --host "$JIRA_SERVER" -u "$USER" -p "$PASSWORD" projects
$ jiracli --host "$JIRA_SERVER" -p "$PASSWORD" worklogs project="$KEY" and sprint=2
$ jiracli --host "$JIRA_SERVER" -u "$USER" worklogs --user "Foo Bar" sprint=2 or sprint=3
$ jiracli --host "$JIRA_SERVER" issues project="$KEY" and type=story or type=issue
$ jiracli --host "$JIRA_SERVER" users "$PROJECT_ID"
Package: ajelastic
Aasaanjobs Elasticsearch SDKLibrary to handle elasticsearch related transactions in Python (for internal usage in Aasaanjobs)RequirementsPython 3.5 and greaterElasticsearch PythonInstallationInstall usingpippip install ajelasticConfigurationThe AJ Elastic library reads configurations from module path specified in the environment
variableAJELASTIC_SETTINGS_MODULEif its a standalone python project, or theDJANGO_SETTINGS_MODULEenvironment variable if its a Django project.export AJELASTIC_SETTINGS_MODULE=tests.settingsExampleBelow is an example settings module that can be consumed by the library# Mandatory Settings# Elasticsearch host and portES_HOST="http://localhost:9200"# The environment suffix that will be added in the Elasticsearch index namesES_ENV="development"# Optional Settings# List of Elasticsearch indicesES_INDICES={"User":{"name":"users",# The index name prefix"doc_type":"user",# Elastic document type"data_functions":{"single":"tests.data:get_user",# Function to fetch a user; should accept a single ID argument"multi":"tests.data:list_users"# Function to fetch list of users; should accept two arguments; limit and offset},"mapping_path":"tests/user_mapping.json"# Path to the JSON mapping of the document structure}}Commands to Sync Data with ElasticsearchThis library provides the following command line scripts to synchronize/initialize dataaj-es-reindexThis command will reindex the documents from scratch fetching data from the function defined in thedata_functions.multisettings of the entity (i.e., withing theES_INDICESsettings).For eg, the below command will reindex the User entity, fetching data from thelist_usersfunction (as specified in the settings)
with a batch size of 100, i.e., in a single request 100 users will be index to elasticsearch.aj-es-reindex User 100
Package: ajm-discord
ajm_discordA collection of several cogs for Discord bots with a few common methods/commands. Specifically for use with thePycordAPI.Install the current version withPyPI:pipinstallajm_discordCogsBaseCogIntentionally sparse cog, just contains an easy way to log and send messages.ListenerCogCog for listeners. Only the on_ready one does anything at the moment, really. TODODeleteCogCog for deleting bot messages in bulk on the user side, and for users to be able to delete bot messages without permissions.TextCogCog for retrieving text. Specifically from Discord threads. Can retrieve text from .txt files, Discord messages, Discord embeds, Microsoft Word documents, and google doc links. Can also convert images/image links to markdown for ease of use.
Package: ajsonapi
ajsonapi: asynchronous JSON APIWhat is it?ajsonapiis a Python package for creating aJSON APIweb server
backed by a database from a user-provided object model.How to specify an object model?Let's look at a simple object model specification.# model.pyfromajsonapiimport(JSON_API,OneToManyRelationship,ManyToOneRelationship,Attribute,String)classPersons(JSON_API):name=Attribute(String)articles=OneToManyRelationship('Articles',rfkey='person_id')classArticles(JSON_API):title=Attribute(String)author=ManyToOneRelationship('Persons',lfkey='person_id')This model contains two class definitions:PersonsandArticles. A person
has a name and can author zero of more articles. An article has a title and
has exactly one author (who is a person). The only parts in the model that may
be unobvious are thelfkeyandrfkeyparameters in the relationship
definitions. They are abbreviations forlocal foreign keyandremote
foreign key, respectively. Ajsonapi uses these parameters to identify thatPersons.articlesandArticles.authorare each other's reverse relationship
and to persist objects and their relationships in the database.For a more elaborate (albeit abstract) object model seeajsonapi's model for
functional testing.How to create a web server?# app.pyfromaiohttp.webimportrun_appfromajsonapiimportApplicationimportmodel# Or directly include the above code snippetasyncdefmake_app():app=Application()awaitapp.connect_database('postgresql://user:password@localhost:5432/db')awaitapp.create_tables()app.add_json_api_routes()returnapp.apprun_app(make_app())What does ajsonapi provide?From the above six line model, ajsonapi creates a web server that supports the
following eighteen operations (combinations of HTTP method and URI) as
described by theJSON API specification.GET, POST                 /persons
GET, PATCH, DELETE        /persons/{id}
GET, POST, PATCH, DELETE  /persons/{id}/relationships/articles
GET                       /persons/{id}/articles
GET, POST                 /articles
GET, PATCH, DELETE        /articles/{id}
GET, PATCH                /articles/{id}/relationships/author
GET                       /articles/{id}/authorAllGEToperations that return a collection support the?include,?fields,?filter,?sort, and?pagequery parameters.  All objects created and
manipulated through the web server are persisted in a Postgres database by ajsonapi.Where to get it?pipinstallajsonapi
Package: ajuste-ebo
Librería de Ajuste de Curva con Kernels en PythonEsta librería proporciona herramientas para realizar ajustes de curva utilizando tres tipos de kernels: gaussiano, tricube y Epanechnikov. Los ajustes de curva son útiles en estadística y análisis de datos para modelar relaciones entre variables.InstalaciónPuedes instalar la librería usandopip:pipinstallajuste_ebo
Package: ajv.programme
programme is a program that writes programmes.This isn’t really intended for general use. It’s something I put
together so someone I know could make nice-ish music-recital programmes,
without having to manually futz with word processor layouts.  But if you
run across it on pypi, you’re welcome to use it.Quick StartInstall Python 3,pip, andprogrammeitself, if they’re not
already present. The commands will differ by OS; this example is for
Mint, Ubuntu, and other Debian-based systems:sudo apt install python3-pip
pip3 install ajv.programmeNow generate a blank performer file, as follows:programme --init > performers.tsvOpenperformers.tsvin your spreadsheet program of choice. It may
prompt you for import settings; the only relevant one is the delimiter,
which should be a tab.Fill in the columns on the spreadsheet. Anything left blank will be
ignored. Save when done. Then:programme performers.tsv output.htmlThat’s it. Open output.html and you should get something usable. If you
specified images in the tsv file, and if those files are present in the
same directory, they’ll be included in the output as portraits.You can runprogramme--helpto see additional options.
Package: akadata
Python Akamai EdgeScape client==============================[![Build Status](https://img.shields.io/travis/redjack/akadata-py/master.svg)](https://travis-ci.org/redjack/akadata-py)Python client for Akamai EdgeScape. Supports Python 2.7/3.3+, and PyPy.## Installation```pip install akadata```## UsageTo lookup an IP address, initialize an `akadata.EdgeScape` object with the hostand port of the EdgeScape Facilitator server, and call its `ip_lookup` method.See the docstring for `akadata.EdgeScape.ip_lookup` for details about theresulting dictionary, parsing, and possible exceptions.```pycon>>> from pprint import pprint>>> from akadata import EdgeScape>>>>>> client = EdgeScape('192.168.59.103', 49158)>>>>>> pprint(client.ip_lookup('208.78.4.5', timeout=1)){u'areacode': [301],u'asnum': [40287],u'bw': 5000,u'city': u'SILVERSPRING',u'company': u'RedJack_LLC',u'continent': u'NA',u'country_code': u'US',u'county': [u'MONTGOMERY'],'default_answer': False,u'dma': 511,u'domain': u'redjack.com',u'fips': ['24031'],'ip': u'208.78.4.5',u'lat': 39.0245,u'long': -77.0094,u'msa': 8872,u'pmsa': 8840,u'region_code': u'MD',u'throughput': u'vhigh',u'timezone': u'EST',u'zip': ['20901', '20902', '20903', '20904', '20905', '20906', '20907','20908', '20910', '20911', '20914', '20915', '20916', '20918','20993', '20997']}```
Package: ak-adb
This repository contains a pure-python implementation of the Android
ADB and Fastboot protocols, using libusb1 for USB communications.This is a complete replacement and rearchitecture of the Android
project’s ADB and fastboot code available athttps://github.com/android/platform_system_core/tree/master/adbThis code is mainly targeted to users that need to communicate with
Android devices in an automated fashion, such as in automated
testing. It does not have a daemon between the client and the device,
and therefore does not support multiple simultaneous commands to the
same device. It does support any number of devices and never
communicates with a device that it wasn’t intended to, unlike the
Android project’s ADB.
Package: akademy
AkademyAkademy is a module containing composable object classes for developing
reinforcement learning algorithms focused on quantitative trading and
time-series forecasting. This module is a work-in-progress and should, at no
time, be assumed to be designed well or be free of bugs.OverviewAkademy is designed using anAgent-Environmentmodel such thatAgent-class
objects ingest information fromEnvironment-class objects (Env), produce
anAction, which is then applied to theEnvironmentwhich results in a
change inStateand possible reward to offer feedback to the agent.Note: this module does not provide any training routines -- only the object class
that can be used to support the implementation of custom training routines.Getting StartedTo installakademyuse the following command in the desired Python 3.7+
environment:pip install akademyOnce installed, developers will have access toAgent,TradeEnv, andNetworkclass objects in which to design Reinforcement Learning algorithms to train models.Sample training routine:fromakademy.models.envsimportTradeEnvfromakademy.models.agentsimportDQNAgentfromakademy.common.utilsimportload_spy_daily# loads the dataset used during trainingdata=load_spy_daily(count=2500)# load the Trading Environmentenv=TradeEnv(data=data,window=50,asset="spy",)# load the agent to trainagent=DQNAgent(action_count=env.action_space.n,state_shape=env.observation_space.shape)# load user-defined training routinetraining_routine(agent=agent,env=env)TestsUnit testing can be run via the following command:python -m unittestFor detailed information the--verboseflag can be used. For more detailed
usage consult theunittestmodule documentation.Available DataThis module comes with minimal data for Agents and Environments to train on.
The current data available is listed below, along with sources for the most
up-to-date versions as well:1. S&P500Location:/data/SPY.CSVStart:1993-01-29End:2023-01-23Total Rows:7,454(excludes header)Header:Date,Open,High,Low,Close,Adj Close,VolumeSource:https://finance.yahoo.com/quote/SPY/history?p=SPYnote: Any data can be used easily enough via conversion into a Pandas DataFrame
object, but must contain information fordateand pricing data foropen,high,low, andcloseas well asvolumesuch that each row has
at least those 6 features or the latter 5 and an index representative of date.NotesGym vs. GymnasiumTheGymproject by OpenAI has been sunset and now maintained asGymnasiumby theFarama-Foundation. TheEnvclasses present here make use of the newerGymnasiumpackage which, among
other differences, produces an extra item in thestepmethod indicating whether
an environment has been truncated.See herePyTorchPyTorch requires some additional consideration for setup depending on use-case.
Akademy uses an approach whereby CPU-based training and inferences are possible
via parameterized function calls. However, GPU use (e.g. CUDA) requires local
considerations. [See here] (https://pytorch.org/get-started/locally/) for a more
in-depth discussion and guide.This module currently uses the 1.* version, though a 2.* version release
is imminent and an upgrade to that version is planned.
Package: akagi
akagiFree software: MIT licenseFeaturesakagi enables you to access various data sources such as Amazon Redshift, Amazon S3 and Google Spreadsheet (more in future) from python.InstallationInstall via pip:pip install akagior from source:$ git clone https://github.com/ayemos/akagi akagi
$ cd akagi
$ python setup.py installSetupTo use RedshiftDataSource, you need to set environment variableAKAGI_UNLOAD_BUCKETthe name
of the Amazon S3 bucket you like to use as intermediate storage of Redshift Unload command.$ export AKAGI_UNLOAD_BUCKET=xyz-unload-bucket.ap-northeast-1To use SpreadsheetDetaSource, you need to set environment variableGOOGLE_APPLICATION_CREDENTIALto
indicate your service account credentials file. You can get the credential fromhere.Associated client has to have read access to the sheets.$ export GOOGLE_APPLICATION_CREDENTIAL=$HOME/.credentials/service-1a2b.jsonExampleRedshiftDataSourcefromakagi.data_sourcesimportRedshiftDataSourceds=RedshiftDataSource('select * from (select user_id, path from logs.imp limit 10000')fordinds:print(d)# iterate on resultS3DataSourcefromakagi.data_sourcesimportS3DataSourceds=S3DataSource.for_prefix('image-data.ap-northeast-1','data/image_net/zebra',file_format='binary')fordinds:print(d)# iterate on resultSpreadsheetDataSourcefromakagi.data_sourcesimportLocalDataSourceds=SpreadsheetDataSource('1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms',# sample sheet provided by Googlesheet_range='Class Data!A2:F31')fordinds:print(d)# iterate on resultLocalDataSourcefromakagi.data_sourcesimportLocalDataSourceds=LocalDataSource('./PATH/TO/YOUR/DATA/DIR',file_format='csv')fordinds:print(d)# iterate on resultCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: akai-mpkmini-mkii-ctrl
Command-line controller for AKAI MPKmini MK IISource–CC BY 2.0Best effort project to overcome the fact that AKAI doesn't seem to be interested in fixing Segmentation faults in theirMPKmini Editor.It currently fixes my own itches but I gladly accept feedback!InstallTo install viaPyPi:pip3 install --user akai-mpkmini-mkii-ctrlPlease note that the dependencypython-rtmidirequires compilation resources to be present on your system. For Debian-like systems for example you need to installsudo apt-get install libasound2-dev. Refer to theproject documentationfor details.To install from source you can use:python3 setup.py install, ormake installwhich will run apipenvincluding linting, tests, etc.Usageakai_mpkmini_mkii_ctrlsupports a set of commands to push or pull presets to and from the device. All commands have a common set of options:-p, --preset NUM     Target preset slot (0 = RAM, 1-4 = Stored preset, default: 0)
-m, --midi-port NUM  MIDI Port on which the device is located (default: 0)
-v, --verbose        Verbose output
--help               Show this message and exit.Commandsprint-preset: Print preset on device in human readable format. In this example it will print the preset stored in slot 1 on the device.python3-makai_mpkmini_mkii_ctrl\--preset1print-presetpull-preset: Pull a binary from the device and write to file.python3-makai_mpkmini_mkii_ctrl\--preset0\pull-preset\--output-fileram-preset.mk2push-preset: Push a local binary preset to the device. This also works withfactory binary presets.python3-makai_mpkmini_mkii_ctrl\--preset2\push-preset\--input-fileresources/factory-patches/preset1.mk2push-config-preset: Push a local configuration preset (Example) to the device. Notice that you are able to combine several input files for easier re-use. YAML and JSON format is supported. The configurations are applied in order, e.g., in this caseBase-Config.yamlwill be extended/overwritten with the properties found inLogic-RetroSynth+Juno.yaml.python3-makai_mpkmini_mkii_ctrl\--preset0\push-config-preset\--input-fileresources/config-presets/Base-Config.yaml\--input-fileresources/config-presets/Logic-RetroSynth+Juno.yamlDevelopmentYou can prepare apipenv-based development environment using:makecleanvenvYou can also install the controller to your system using:makeinstallTo use the localpipenv-based version you can use the following command from where you cloned the repository:pipenvrunpythonakai_mpkmini_mkii_ctrlResourcesThe implementation is based upon the following resources:https://github.com/gljubojevic/akai-mpk-mini-editorhttps://github.com/mungewell/mpd-utilshttps://www.snoize.com/midimonitor/https://github.com/gbevin/SendMIDIhttps://github.com/gbevin/ReceiveMIDIhttps://www.akaipro.com/mpk-mini-mkii
Package: akamaichinaCDN
A Python Class for Akamai China CDN ManagerAn Object oriented implementation of Akamai China CDN Portal.CredentialsIn order to use this configuration, you need to:Set up your credential files as described in theauthorizationandcredentialssections of the getting started guide on developer.akamai.com.When working through this process you need to give grants for the property manager API and the User Admin API (if you will want to move properties).  The section in your configuration file should be called 'default'.OverviewAn Object oriented implementation of Akamai China CDN ManagerInstall pip package available$ pip install akamaichinaCDNInstantiate the object.>>> from akamaichinaCDN import ChinaCDNManager
>>> china_manager = ChinaCDNManager('/Users/apadmana/.edgerc')Whitelist Hostname>>> china_manager.whiteList(newhostname)Class Definitionclass ChinaCDNManager():
    def __init__(self,edgercLocation,accountSwitchKey=None):
      self.icp_info = ''
        self._edgerc = ''
        self._prdHttpCaller = ''
        self._session = ''
        self._baseurl_prd = ''
        self._host = ''
        self._icp_info = ''
        self._icp_entities_info = ''
        self.accountSwitchKey = ''
        self._edgehostnames = ''
        self._groups = ''
        self._appmapping = ''
        self._legalmapping = ''

    def getICPEntities(self)
    def getICPNumbers(self)
    def getEdgeHostNames(self)
    def getGroups(self)
    def getProperties(self)
    def getPropertyInfo(self,hostname)
    def getDeProvisionPolicy(self,edgeHostname)
    def specifyDeProvisionPolicy(self,edgeHostname)
    def getProvisionStateChange(self,hostname,changeId)
    def getcurrentProvisionStateChange(self,hostname)
    def getProvisionStatus(self,status_filter=None)
    def createPropertyHostname(self,hostname,icpNumberId,serviceCategoryName,groupId)
    def whiteList(self,hostname)
Package: akamaihttp
A Python Class for Akamai PropertyAn Object oriented implementation of Akamai Property.
The advantage of Akamai Property class is application developers need not know about the PAPI calls and their usage. Application developers can just focus on getting their work done on Property Manager configs programmatically using the objects of AkamaiProperty.CredentialsIn order to use this configuration, you need to:Set up your credential files as described in theauthorizationandcredentialssections of the getting started guide on developer.akamai.com.When working through this process you need to give grants for the property manager API and the User Admin API (if you will want to move properties).  The section in your configuration file should be called 'papi'.OverviewThe advantage of Akamai Property class is application developers need not know about the PAPI calls and their usage. Application developers can just focus on getting their work done on Property Manager configs programmatically using the objects of AkamaiProperty.Install Dependencies If you are using source code.$ pip install -r requirements.txtInstall pip package available$ pip install akamaipropertyInstantiate the object.>>> from akamaiproperty import AkamaiProperty
>>> myProperty = AkamaiProperty("/Users/apadmana/.edgerc","test_bulkseach_update_1","<accountSwitchKey>")
>>> myProperty = AkamaiProperty("/Users/apadmana/.edgerc","test_bulkseach_update_1")Print Basic Information>>> myProperty.printPropertyInfo()
Property Name: test_bulkseach_update_1
Contract Id: ctr_C-1IE2OHM
Group Id: grp_163363
Active Staging Version: 18
Active Production Version: 18Create a new version>>> myProperty.createVersion(18)
'78'Get rule Tree>>>myProperty.getRuleTree(18)
{'accountId': 'act_B-C-1IE2OH8', 'contractId': 'ctr_C-1IE2OHM', 'groupId': 'grp_163363', 'propertyId': 'prp_605086', 'propertyName': 'test_bulkseach_update_1', 'propertyVersion': 18, 'etag': 'd0d28a6b71e665144955f7f7e1ff214933d119d7', 'rules':.....}Activate the config>>>myProperty.activateStaging(18,"testing activation",["apadmana@akamai.com"])
TrueClass Definitionclass AkamaiProperty():
    def __init__(self,edgercLocation, name, accountSwitchKey=None):
        self.name = name
        self.contractId = ''
        self.groupId = ''
        self.propertyId = ''
        self.stagingVersion = 0
        self.productionVersion = 0
        self.accountSwitchKey = ''

    def printPropertyInfo(self)
    def getStagingVersion(self)
    def getProductionVersion(self)
    def getRuleTree(self,version)
    def updateRuleTree(self,version,jsondata)
    def createVersion(self,baseVersion)
    def activateStaging(self,version,notes,email_list)
    def activateProduction(self,version,notes,email_list,peer_review_email,customer_email)