ManipulaPy

v1.3.2.post1 suspicious
6.0
Medium Risk

A comprehensive Python package for robotic manipulator analysis and control

🤖 AI Analysis

Final verdict: SUSPICIOUS

The package ManipulaPy exhibits moderate risks due to potential obfuscation techniques and shell executions, which require closer scrutiny to confirm legitimacy.

  • High obfuscation risk
  • Potential shell execution
Per-check LLM notes
  • Network: No network calls detected, which is typical and safe.
  • Shell: Shell execution patterns indicate the package might be performing system commands, which could be legitimate but requires further investigation to ensure there's no unauthorized access or behavior.
  • Obfuscation: The code shows patterns of dynamic module importing with conditional checks that may be used to evade detection or analysis.
  • Credentials: No suspicious patterns for harvesting credentials or secrets were detected.
  • Metadata: The maintainer has only one package, indicating a potentially new or less active account.

🔬 Heuristic Checks

✓ Outbound Network Calls

No suspicious network call patterns found

⚠ Code Obfuscation score 8.0

Found 4 obfuscation pattern(s)

  • """ try: module = __import__(module_name, fromlist=["*"]) return isinstance(module, types.ModuleType) exc
  • """ try: module = __import__(module_name) if module_name == "cupy": try:
  • """ try: module = __import__(module_name) return not hasattr(module, "_name") or not str(modu
  • """ try: module = __import__(module_name) return ( not hasattr(module, "_name") o
⚠ Shell / Subprocess Execution score 10.0

Found 5 shell execution pattern(s)

  • ) try: proc = subprocess.run( [sys.executable, "-c", probe], stdo
  • process result = subprocess.run( ["catkin_find", package_name],
  • alue_str}") result = subprocess.run( cmd, capture_output=True,
  • se try: result = subprocess.run( [nvidia_smi, "-L"], check=False,
  • st runner. """ proc = subprocess.run( [ sys.executable, "-c",
✓ Credential Harvesting

No credential harvesting patterns detected

✓ Typosquatting

No typosquatting candidates detected

✓ Registered Email Domain

Email domain looks legitimate: gmail.com>

✓ Suspicious Page Links

All external links appear legitimate

✓ Git Repository History

Repository boelnasr/ManipulaPy appears legitimate

⚠ Maintainer History score 2.0

1 maintainer concern(s) found

  • Author "Mohamed Aboelnasr" appears to have only 1 package on PyPI (new or inactive account)
✓ Known CVE Vulnerabilities

No known vulnerabilities found in OSV database.

💡 AI App Starter Prompt

Use this prompt to build a project with ManipulaPy 
Your task is to develop a user-friendly desktop application using Python that leverages the ManipulaPy package to simulate and analyze the kinematics of a robotic arm. This application will allow users to input various parameters related to the robotic arm, such as joint angles, lengths, and offsets, and then visualize the resulting position and orientation of the end-effector in real-time.

The application should include the following features:
1. User Interface: Create a simple yet intuitive graphical user interface (GUI) using a library like PyQt or Tkinter. The GUI should have fields for entering joint angles, lengths, and offsets, as well as buttons for initiating calculations and visualizations.
2. Kinematic Analysis: Implement forward kinematics to calculate the position and orientation of the end-effector based on the input joint angles. Use ManipulaPy's functionalities to perform these calculations efficiently.
3. Visualization: Utilize a plotting library like Matplotlib to visualize the robotic arm and its end-effector in 3D space. The visualization should update dynamically as the user changes input parameters.
4. Inverse Kinematics Solver: Include an inverse kinematics solver that allows users to specify the desired position and orientation of the end-effector and computes the corresponding joint angles. Again, rely on ManipulaPy for the underlying mathematics.
5. Documentation: Provide clear documentation explaining how to install the application, use its features, and interpret the results. Include examples and screenshots.
6. Extensibility: Design the application in a modular way so that it can easily be extended to support different types of robotic arms or additional features in the future.

To achieve these goals, you will need to utilize ManipulaPy's core features such as defining robotic manipulators, performing forward and inverse kinematics, and possibly other advanced functionalities provided by the package. Your final product should be a robust tool for educational purposes or for quick prototyping in robotics.