Saravanan666/pypi-org huggingface dataset:
Package: slapstack-controls
SLAPStack-ControlsThis package contains several control heuristics associated with the SLAPStack
block stacking warehouse (BSW) simulation. The code is hosted together with the
simulation ongithub.
SLAPStack contains two use cases, namelyWEPAStacksandCrossstacks.
See the linked repository for more information.ForWEPAStacks, the following storage location allocation problem (SLAP)
strategies were implemented and tested (a comparison of these strategies is
available through[3]):Closest open pure lane (COPL) andClass-based popularity with the following stock keeping unit (SKU) popularity
measures:SKU turnover time (indirectly proportional to popularity)The historic number of picks per SKU (directly proportional to popularity)The number of future SKU picks over the next planning period, e.g. week
(directly proportional to popularity)The historic SKU throughput calculated as the sum of picks and deliveries
per SKU (directly proportional to popularity)The future SKU throughput over the next planning periodForCrossStacks(publication pending), the implemented strategies are:Closest to destination (CTD),Closest open location (COL),Random location (RND), andTwo dual command cycle inspired heuristics:Closest to the next delivery order (CTNR)Shortest leg (SL)Note that theCrossStacksSLAP strategies could be applied to theWEPAStacksuse case and vice-versa, however this application has not yet been tested.The following unit load selection problem (ULSP) policies are implemented:Batch Last In First Out (BLIFO)Citing the ProjectIf you useSLAPStack,WEPAStacksorCrossStacksin your research, you can
cite this repository as follows:@misc{rinciog2023slapstack
    author = {Rinciog, Alexandru and Pfrommer, Jakob and Morrissey Michael 
      and Sohaib Zahid and Vasileva, Anna and Ogorelysheva, Natalia and 
      Rathod, Hardik and Meyer Anne},
    title = {SLAPStack},
    year = {2023},
    publisher = {GitHub},
    journal = {GitHub Repository},
    howpublished = {\url{https://github.com/malerinc/slapstack.git}},
}References[1]Pfrommer, J., Meyer, A.: Autonomously organized
block stacking warehouses: A review of decision problems and major challenges.
Logistics Journal: Proceedings 2020(12) (2020)[2]Rinciog, A., Meyer, A.: Fabricatio-rl:
A reinforcement learning simulation framework for production scheduling.
In: 2021 Winter Simulation Conference (WSC).
pp. 1â€“12. IEEE (2021)[3]Pfrommer, J.; Rinciog, A.; Zahid, S.; Morrissey, M;
Meyer A. (2022): SLAPStack: A Simulation Framework and a Large-Scale Benchmark
Use Case for Autonomous Block Stacking Warehouses.
International Conference on Computational Logistics (ICCL) 2022.
Package: slash3
Slash3Slash3is a Python package for building and navigating Amazon Web Services S3 URIs.What's an S3 URI?An S3 URI (Uniform Resource Identifier) is a string that identifies a bucket, and optionally a key, in Amazon Web Services S3.The pattern for an S3 URI iss3://BUCKET/KEY.For example:The bucket named "circus" can be described by the URIs3://circus/The key prefix for all circus images can be described by the URIs3://circus/images/The path to Steve's staff photograph can be described by the URIs3://circus/images/steve.jpgInstallationSlash3 requires Python 3.9 or later and can be installed fromPyPI.pipinstallslash3UsageConstruct a URI from a URIIf you've already got a string URI then pass it directly toS3Uri:fromslash3importS3Uriuri=S3Uri("s3://circus/")uri.bucket# circusuri.key#uri=S3Uri("s3://circus/images/clowns.jpg")uri.bucket# circusuri.key# images/clowns.jpgConstruct a URI from a bucket and keyTo construct an S3 URI from a bucket name and an optional key, callS3Uri.to_uri:fromslash3importS3Uriuri=S3Uri.to_uri("circus")# s3://circus/uri=S3Uri.to_uri("circus","images/clowns.jpg")# s3://circus/images/clowns.jpgJoin a key suffix with a "/" delimiterTo join a key suffix with a "/" delimiter -- for example, to join an object's name to a key prefix -- callS3Uri.join()or use the/operator:fromslash3importS3Uriuri=S3Uri("s3://circus/")images=uri/"images"# s3://circus/imagesclowns=images/"clowns.jpg"# s3://circus/images/clowns.jpgSlash3 will automatically normalise away any consecutive "/" delimiters.Append a key suffix without a delimiterTo append a key suffix without a delimiter, callS3Uri.append()or use the+operator:fromslash3importS3Uristaff=S3Uri("s3://circus/staff-")steve=staff+"steve.jpg"# s3://circus/staff-steve.jpgpenny=staff+"penny.jpg"# s3://circus/staff-penny.jpgGet the parent key prefixTo get a URI's parent key prefix, callS3Uri.parent:fromslash3importS3Uristeve=S3Uri("s3://circus/images/steve.jpg")steve.parent# s3://circus/images/Get the key's leaf / file namefromslash3importS3Uristeve=S3Uri("s3://circus/images/steve.jpg")steve.leaf# steve.jpgGet a relative key pathTo discover the relative path between a specific URI and a parent URI, callS3Uri.relative_to:fromslash3importS3Uriavatar=S3Uri("s3://circus/images/staff/steve.jpg")images="s3://circus/images/"avatar.relative_to(images)# staff/steve.jpgSupportPlease submit all your questions, feature requests and bug reports atgithub.com/cariad/slash3/issues. Thank you!LicenceSlash3 isopen-sourceand released under theMIT License.You don't have to give attribution in your project, but -- as a freelance developer with rent to pay -- I appreciate it!AuthorHello! 👋 I'mCariad Eccleston, and I'm a freelance Amazon Web Services architect, DevOps evangelist, CI/CD pipeline engineer and backend developer.You can find me atcariad.earth,github/cariad,linkedin/cariadand on Mastodon at@cariad@tech.lgbt.
Package: slashbot
slashbotSlashbot makes it easy to create slash commands using AWS Lambda functions. These can be handy for creating a secure way to execute automated tasks, even from a mobile device.Features:Uses Slack Apps API (rather than the legacy slash command API)Request authentication following Slack's recommended best practice (https://api.slack.com/authentication/verifying-requests-from-slack)Ability to support multiple slash commands with a single botSimple ACL model enables you to limit certain commands to specific users.
Package: slash-cog
discord.py/slashcogA drop-in vanilla discord.py cog that acts as a translation layer to add slash command support with little to no code modifications, no forks neededFeatures:Automatically generates a command map with argument listing for the entire botWraps around existing discord.pyContext, almost no code modifications neededAutomatic Multi-Instance bot detection (currently, it will only register if there is no shards or the bot runsshard0)Storage-less automatic permissions syncingGeneral TO-DOs & RFCs:Make the cog more modular in order to support more customizationsAvoid monkey-patching command checksTranslation forhas_roleUnsupported Features (Unsupported by Discord):Translation for Custom checksTranslation for@commands.check_any()is_nsfw(commands currently hidden)*has_permissions(only roles and user IDs are accepted)bot_has_(any)?_roleguild_onlydm_onlyFork Support:I personally won't provide support for forks as for simplicity's sake I will be basing this cog onRapptz/discord.pymasterv2.0.0a. However, fork-specific pull requests are allowed.A word though, because everyone is making their own forks of discord.py, I would suggest changing up the readme to include what changes and features the fork has added apart from API parity and maintenance just to make everybody's lives easier.3-step Usage:Simply install the pip package with:pipinstall-Uslash_cogThen in your bot's cog loader, load the command handler (CRITICAL:Load it as the first extension as the cog needs to monkey patch command checks):bot.load_extension("slash_cog")Create a new cog to register the commands globally or per-guild, you may copythe example.Preferably, you should only register the commands once and keep them registered as Discord will retain the command data unless you replace them, but the code for this is for you to decide and/or modify the example to.P.S. If this project / POC has been usefulsponsor mepls, iambroke
Package: slash-command-decorator
# slash-command-decoratorslash-command-decorator is a simple decorator for the use of AWS Lambda as the [Slack Slash Command](https://api.slack.com/slash-commands) backend.[![CircleCI](https://circleci.com/gh/penta515/slash-command-decorator.svg?style=svg)](https://circleci.com/gh/penta515/slash-command-decorator) [![Code Climate](https://codeclimate.com/github/penta515/slash-command-decorator/badges/gpa.svg)](https://codeclimate.com/github/penta515/slash-command-decorator)## InstallationThe latest release of slash-command-decorator can be installed via pip```$ pip install slash-command-decorator```An alternative install method would be manually installing it leveraging `setup.py````$ git clone https://github.com/penta515/slash-command-decorator$ cd slash-command-decorator$ python setup.py install```## Set Query String in eventIn handler function `event.body` parameter, it is necessary to set up URL query string that was tranmitted by Slack###Example event.body```python"token=aCec9XZPS6klbnAAAAAAAAAA&team_id=T0AAAAAAA&team_domain=test-domain&channel_id=C0AAAAAAA&channel_name=general&user_id=U0AAAAAAA&user_name=hoge&command=%2Fcommand&text=hoge&response_url=https%3A%2F%2Fhooks.slack.com%2Fcommands%2FT0JQU92NA%2F1234567890%2Faaaaaaaaaaaaaaaaaaa"```## Usage examplesUsage examples are included in the [samples directory](https://google.co.jp)```pythonfrom slash_command_decorator.slash_command import SlashCommandfrom slash_command_decorator import (lambda_manager,respond_to_option)SLACK_API_TOKEN = "xoxp-12345678901-12345678901-12345678901-hogefugapiyo"CONFIG = {"username": "Slash Command","icon_emoji": ":penguin:"}@lambda_managerdef lambda_handler(event, context):@respond_to_option("^help$")def help_option(reaction):reaction.ephemeral("HELP!")@respond_to_option("^hoge$")def hoge_option(reaction):reaction.in_channel("HOGE!")@respond_to_option("^fuga$")def fuga_option(reaction):reaction.send("FUGA!")@respond_to_option("^piyo$")def piyo_option(reaction):reaction.reply("PIYO!")SlashCommand(token=SLACK_API_TOKEN,config=CONFIG).start(help_option,hoge_option,fuga_option,piyo_option)```###Types of Responses####1.ephemeral```python@respond_to_option("^help$")def help_option(reaction):reaction.ephemeral("HELP!")```![ephemeral](https://github.com/penta515/slash-command-decorator/blob/develop/images/help.gif)####2.in_channel```python@respond_to_option("^hoge$")def hoge_option(reaction):reaction.in_channel("HOGE!")```![in_channel](https://github.com/penta515/slash-command-decorator/blob/develop/images/hoge.gif)####3.send```python@respond_to_option("^fuga$")def fuga_option(reaction):reaction.send("FUGA!")```![in_channel](https://github.com/penta515/slash-command-decorator/blob/develop/images/fuga.gif)####4.reply```python@respond_to_option("^PIYO$")def piyo_option(reaction):reaction.reply("PIYO!")```![in_channel](https://github.com/penta515/slash-command-decorator/blob/develop/images/piyo.gif)## Running tests```$ py.test tests```## License[![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE)
Package: slash-help
slash-helpdiscord-py-interactions slash command helpJoin ourDiscord serverto ask questions, report bugs, or suggest features!Install:pipinstall-Uslash-helpRequirements (automatically installed when installing slash-help):discord-py-interactions (version 3.0.2)discord.py (version 1.7.3)dinteractions-PaginatorthefuzzLevenshteinExample:Usage:fromdiscord_slashimportSlashCommandfromdiscord.extimportcommandsfromslash_helpimportSlashHelpbot=commands.Bot("your_prefix",help_command=None)slash=SlashCommand(bot,sync_commands=True)# sync_commands=True preferredhelp_slash=SlashHelp(bot,slash,"your_bot_token",dpy_command=True)# if you want a dpy command as well, and to show dpy commands in the help# and its done!More customized:fromdiscord_slashimportSlashCommandfromdiscord.extimportcommandsfromslash_helpimportSlashHelpbot=commands.Bot("your_prefix",help_command=None)slash=SlashCommand(bot,sync_commands=True)# sync_commands=True preferredhelp_slash=SlashHelp(bot,slash,"your_bot_token",dpy_command=True,auto_create=False)@bot.command()asyncdefhelp(ctx,*,command=None):awaithelp_slash.send_help(ctx,command,prefix="your_prefix")# you can override the prefix here# and also in SlashHelp()@slash.slash(name="help")asyncdef_help(ctx,command=None):awaithelp_slash.send_help(ctx,command,guild_id=ctx.guild.id)classSlashHelpArguments:Required:bot:Union[commands.Bot, discord.Client]- the bot variableslash:SlashCommand- the slash variabletoken:str- the bot token, required for fetching slash commands from Discord APIOptional:guild_ids:Optional[List[int]] = None- a list of guild/server IDs to register the help slash commandguild_id:Optional[int] = None- what guild ID to use for getting guild commandsKeyword Arguments:color:Optional[discord.Color] = discord.Color.default()- the color of the embedcolour- alias ofcolortimeout:Optional[int] = 60- the number of seconds till paginator timeout, specifyNonefor no timeoutfields_per_embed:Optional[int] = 4- the number of fields per embedfooter:Optional[str] = None- footer for the embedsfront_description:Optional[str] = None- description in the first embedno_category_name:Optional[str] = "No Category"- value for the No Category fieldno_category_description:Optional[str] = "No description"- value for the No Category description fieldextended_buttons:Optional[bool] = True- to use the first and last buttonsuse_select:Optional[bool] = True- whether to use the selectauthor_only:Optional[bool] = False- whether to have buttons work only for the authoruse_subcommand:Optional[bool] = False- to have a subcommand/help bot_namebot_name:Optional[str] = None- needed to useuse_subcommanddpy_command:Optional[bool] = False- whether to make a discord.py command as wellmax_search_results:Optional[int] = 12- maximum search resultssync_commands:Optional[bool] = False- if you want to get commands every single timeblacklist:Optional[List[str]] = None- commands or cogs to blacklist, case sensitiveprefix:Optional[str] = None- overridesbot.command_prefix
Package: slashpatch
vcokltfre/SlashPatchA command handler/dispatcher webserver for Discord slash commandsExample:fromslashpatchimportServer,Context,command,Cogapp=Server('c293758d88bc26d54963f05676a8fa6c3404570169e350afd5c1f318bf52732a')classExample(Cog):@command(name="example")asyncdefexample(self,ctx:Context):print(ctx.raw)returnctx.respond("Hello, world!",ephemeral=True)@command(name="cases")asyncdefcases(self,ctx:Context):returnctx.respond(embed={"description":"h"})app.add_cog(Example())Then run:uvicorn main:app --host 0.0.0.0
Package: slash-step
slash-stepBuild StatusSupported VersionsLatest VersionCreate a more granular subSTEPforSlashtests.Some scenarios can be long and complex, but you still want to have them as a single logical test.
Steps allow to document subsections of a test, and also provide some handy hooks to perform actions inside a test (such as validations).To continue the microwave example fromSlash'sdocs:fromslashimportgfromslash_stepimportSTEP,hooks@hooks.step_end.registerdefmeasure_temperature():ifg.microwave.temperature>180:logger.warn("Microwave is over heating!")deftest_cook_chicken():withSTEP("Defrost chicken"):# ...withSTEP("Cook"):# ...withSTEP("Eat"):# Yum...assertg.chicken.is_cooked()
Package: slat
SLaTSimpleLambdaToolkitCollection of reusable Python tools for lambda development.This project is meant to :meat_on_bone: (or :corn:) these requirementsAs a lambda developer I want to write as little boilerplate as possibleAs a lambda developer I want to ensure I produce high value, discoverable logsAs a lambda developer I want to ensure I sends proper, consistent, well formed responsesAs a lambda developer I want ToBeDeterminedExample hello world Lambdafromslat.log_utilimportLogUtilfromslat.responseimportLambdaProxyResponsefromslat.typesimportJsonapiBody# initiate you logger outside the handlerlog=LogUtil.init_logger(env_var_name='LOG_LEVEL',default_level='INFO')deflambda_handler(event,context):# bind the request id to the loggerLogUtil.init_request({'request_id':context.aws_request_id})# make log statements as normallog.debug('Lambda Handler Event',lambda_handler_event=event)# prepare a Jsonapi payload (https://jsonapi.org/)response_body=JsonapiBody(data={'hello':'world!'},errors=[],meta={})# respond in the expected APIGateway lambda proxy format (https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-output-format)returnLambdaProxyResponse.respond(200,response_body,context)Slat ToolsResponsesTBDocumentedLoggingStructlogis used for structured JSON loggingExample Usageimportloggingfromslat.log_utilimportLogUtillog=LogUtil.init_logger(default_level='INFO',correlation_id_key_val={'request_id':'999'})log.info('is this JSON: {"answer": 42}')log.error("the log message",some="value",extra_data=[1,2,3,"4"])# only OUR logger will render as JSONlogging.getLogger("test").warning("hello")output:{"event": "is this JSON: {\"answer\": 42}", "level": "info", "logger": "slat.log_util", "request_id": "999", "timestamp": "2019-11-06T21:04:33.517295Z"}
{"event": "the log message", "extra_data": [1, 2, 3, "4"], "level": "error", "logger": "slat.log_util", "request_id": "999", "some": "value", "timestamp": "2019-11-06T21:04:33.517652Z"}
helloFor test runs you can add an ENV flagTESTING_RUN=trueand log statements will be written to./testing.logTESTING_RUN=true pytestRunning testspytest

# with coverage 
pytest --cov=slat

# generage html report
coverage html
open ./htmlcov/index.htmlDevelopingcreate file ~/.pypirc[distutils]
index-servers =
  pypi
  pypitest

[pypi]
repository: https://upload.pypi.org/legacy/
username:
password:

[pypitest]
repository: https://test.pypi.org/legacy/
username:
password:build# tick to semver `version` in setup.py
rm -rf dist
python setup.py bdist_wheel --universalpypitesttwine upload --repository pypitest dist/*
pip install slat --index-url https://test.pypi.org/simple/ --upgradepypitwine upload --repository pypi dist/*
pip install slat --upgrade
Package: slate
Slate is a Python package that simplifies the process of extracting
text from PDF files. It depends on the PDFMiner package.Slate provides one class, PDF. PDF takes a file-like object and
will extract all text from the document, presentating each page
as a string of text:>>> with open('example.pdf') as f:
...    doc = slate.PDF(f)
...
>>> doc
[..., ..., ...]
>>> doc[1]
'Text from page 2...'If your pdf is password protected, pass the password as the
second argument:>>> with open('secrets.pdf') as f:
...     doc = slate.PDF(f, 'password')
...
>>> doc[0]
"My mother doesn't know this, but..."More complex operationsIf you would like access to the images, font files and other
information, then take some time to learn the PDFMiner API.What is wrong with PDFMiner?Getting simple things done, like extracting the text
is quite complex. The program is not designed to return
Python objects, which makes interfacing things irritating.It’s an extremely complete set of tools, with multiple
and moderately  steep learning curves.It’s not written with hackability in mind.
Package: slate3k
THIS PROJECT IS A FORK OF slateOriginal project ishttps://github.com/timClicks/slate. It is not supported Python3.
I thank the original writer @timClicks and other contributors.SlateSlate is a Python package that simplifies the process of extracting
text from PDF files. It depends on the PDFMiner package.Slate provides one class, PDF. PDF takes a file-like object and
will extract all text from the document, presentating each page
as a string of text:>>> with open('example.pdf', 'rb') as f:
...    doc = slate.PDF(f)
...
>>> doc
[..., ..., ...]
>>> doc[1]
'Text from page 2...'If your pdf is password protected, pass the password as the
second argument:>>> with open('secrets.pdf', 'rb') as f:
...     doc = slate.PDF(f, 'password')
...
>>> doc[0]
"My mother doesn't know this, but..."More complex operationsIf you would like access to the images, font files and other
information, then take some time to learn the PDFMiner API.What is wrong with PDFMiner?Getting simple things done, like extracting the text
is quite complex. The program is not designed to return
Python objects, which makes interfacing things irritating.It’s an extremely complete set of tools, with multiple
and moderately  steep learning curves.It’s not written with hackability in mind.
Package: slate-db
# Slate DBA Python wrapper for executing Slate Custom SQL in Python.## InstallationYou must first install the [ODBC Driver for SQL Server](https://docs.microsoft.com/en-us/sql/connect/odbc/download-odbc-driver-for-sql-server?view=sql-server-2017).Then install via pip:```pip install git+https://github.com/jamie-r-davis/slate_db```## UsageThe `SlateDB.select` method returns a generator which will yield any records that match your `sql` query. By default, each record is returned as an AttrDict, enabling access via keys or via attributes:```python>>> from slate_db import SlateDB>>> db = SlateDB(server='your.server.com',port=1441,db='dbname-test',username='user',password='secret-password')# select all records with last name "Smith">>> sql = """select * from person where last = 'Smith'""">>> for record in db.select(sql):>>>     print("Via attribute: {} <{}>".format(record.name, record.email))>>>     print("Via key: {} <{}>".format(record['name'], record['email']])# Via attribute: Smith, John <john.smith@example.com># Via key: Smith, John <john.smith@example.com># Via attribute: Smith, Granny <granny.smith@example.com># Via key: Smith, Granny <granny.smith@example.com>```
Package: slave
Slave is a micro framework designed to simplify instrument communication and
control and comes with a variety of ready to use device drivers.OverviewSlave provides an intuitive way of creating instrument api’s, inspired by
object relational mappers.from slave.iec60488 import IEC60488, PowerOn
from slave.driver import Command
from slave.types import Integer, Enum

class Device(IEC60488, PowerOn):
    """An iec60488 conforming device api with additional commands."""
    def __init__(self, transport):
        super(Device, self).__init__(transport)
        # A custom command
        self.my_command = Command(
            'QRY?', # query message header
            'WRT',  # command message header
            # response and command data type
            [Integer, Enum('first', 'second')]
        )Commands mimic instance attributes. Read access queries the device, parses and
converts the response and finally returns it. Write access parses and converts
the arguments and sends them to the device. This leads to very intuitive
interfaces.Several device drivers are already implemented, and many more are under
development. A short usage example is given below:import time
from slave.transport import Visa
from slave.srs import SR830

lockin = SR830(Visa('GPIB::08'))
# configure the lockin amplifier
lockin.reserve = 'high'
lockin.time_constant = 3
# take 60 measurements and print the result
for i in range(60):
    print lockin.x
    time.sleep(1)RequirementsPython 2.6 or higherSphinx (optional, to build the documentation)sphinx_bootstrap_theme(optional, default theme used for the documentation)distribute (Python 3.x)InstallationTo install Slave, simply typepython setup.py installDocumentationSlave is fully documented. Both the lateststableas well as thedevelopdocumentations are available online. To build the documentation manually, e.g.
the html documentation, navigate into the/doc/subfolder and executemake html. For a prettier theme, install sphinx_boostrap_theme first
(pip install sphinx_bootstrap_theme).LicensingYou should have received a copy of theGNU General Public Licensealong
with slave; see the file COPYING.